/* -*-c++-*- OpenRTI - Copyright (C) 2009-2023 Mathias Froehlich
 *
 *
 * This file is part of OpenRTI.
 *
 * OpenRTI is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * OpenRTI is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with OpenRTI.  If not, see <http://www.gnu.org/licenses/>.
 *
 * This file is autogenerated by messagegen.py. Do not edit!
 *
 */

#ifndef OpenRTI_Message_h
#define OpenRTI_Message_h

#include <map>
#include <set>
#include <vector>
#include "AbstractMessage.h"
#include "AbstractMessageDispatcher.h"
#include "Handle.h"
#include "VariableLengthData.h"

namespace OpenRTI {

enum CallbackModel {
  HLA_IMMEDIATE,
  HLA_EVOKED
};

enum OrderType {
  RECEIVE,
  TIMESTAMP
};

enum TransportationType {
  RELIABLE,
  BEST_EFFORT
};

enum SubscriptionType {
  Unsubscribed,
  SubscribedPassive,
  SubscribedActive
};

enum PublicationType {
  Unpublished,
  Published
};

enum ResignAction {
  UNCONDITIONALLY_DIVEST_ATTRIBUTES,
  DELETE_OBJECTS,
  CANCEL_PENDING_OWNERSHIP_ACQUISITIONS,
  DELETE_OBJECTS_THEN_DIVEST,
  CANCEL_THEN_DELETE_THEN_DIVEST,
  NO_ACTION
};

enum RestoreFailureReason {
  RTI_UNABLE_TO_RESTORE,
  FEDERATE_REPORTED_FAILURE_DURING_RESTORE,
  FEDERATE_RESIGNED_DURING_RESTORE,
  RTI_DETECTED_FAILURE_DURING_RESTORE
};

enum RestoreStatus {
  NO_RESTORE_IN_PROGRESS,
  FEDERATE_RESTORE_REQUEST_PENDING,
  FEDERATE_WAITING_FOR_RESTORE_TO_BEGIN,
  FEDERATE_PREPARED_TO_RESTORE,
  FEDERATE_RESTORING,
  FEDERATE_WAITING_FOR_FEDERATION_TO_RESTORE
};

enum SaveFailureReason {
  RTI_UNABLE_TO_SAVE,
  FEDERATE_REPORTED_FAILURE_DURING_SAVE,
  FEDERATE_RESIGNED_DURING_SAVE,
  RTI_DETECTED_FAILURE_DURING_SAVE,
  SAVE_TIME_CANNOT_BE_HONORED
};

enum SaveStatus {
  NO_SAVE_IN_PROGRESS,
  FEDERATE_INSTRUCTED_TO_SAVE,
  FEDERATE_SAVING,
  FEDERATE_WAITING_FOR_FEDERATION_TO_SAVE
};

enum ServiceGroupIndicator {
  FEDERATION_MANAGEMENT,
  DECLARATION_MANAGEMENT,
  OBJECT_MANAGEMENT,
  OWNERSHIP_MANAGEMENT,
  TIME_MANAGEMENT,
  DATA_DISTRIBUTION_MANAGEMENT,
  SUPPORT_SERVICES
};

enum LowerBoundTimeStampCommitType {
  TimeAdvanceCommit = 1,
  NextMessageCommit = 2,
  TimeAdvanceAndNextMessageCommit = 3
};

enum SwitchesType {
  InteractionRelevanceAdvisorySwitchesType,
  ObjectClassRelevanceAdvisorySwitchesType,
  AttributeRelevanceAdvisorySwitchesType,
  AttributeScopeAdvisorySwitchesType,
  AutoProvideSwitchesType,
  ConveyRegionDesignatorSetsSwitchesType,
  ServiceReportingSwitchesType
};

typedef bool Bool;

typedef std::string String;

typedef uint32_t Unsigned;

typedef double Double;

typedef std::vector<AttributeHandle> AttributeHandleVector;

typedef std::vector<FederateHandle> FederateHandleVector;

typedef std::vector<ParameterHandle> ParameterHandleVector;

typedef std::vector<DimensionHandle> DimensionHandleVector;

typedef std::set<DimensionHandle> DimensionHandleSet;

typedef std::vector<ObjectInstanceHandle> ObjectInstanceHandleVector;

typedef std::vector<RegionHandle> RegionHandleVector;

typedef std::vector<ModuleHandle> ModuleHandleVector;

typedef std::vector<String> StringVector;

typedef std::set<String> StringSet;

typedef std::pair<FederateHandle, Bool> FederateHandleBoolPair;

typedef std::vector<FederateHandleBoolPair> FederateHandleBoolPairVector;

class RangeBoundsValue;
typedef std::pair<DimensionHandle, RangeBoundsValue> DimensionHandleRangeBoundsValuePair;

typedef std::vector<DimensionHandleRangeBoundsValuePair> RegionValue;

typedef std::vector<RegionValue> RegionValueList;

typedef std::pair<RegionHandle, DimensionHandleSet> RegionHandleDimensionHandleSetPair;

typedef std::vector<RegionHandleDimensionHandleSetPair> RegionHandleDimensionHandleSetPairVector;

typedef std::pair<RegionHandle, SpaceHandle> RegionHandleSpaceHandlePair;

typedef std::vector<RegionHandleSpaceHandlePair> RegionHandleSpaceHandlePairVector;

typedef std::pair<RegionHandle, RegionValue> RegionHandleRegionValuePair;

typedef std::vector<RegionHandleRegionValuePair> RegionHandleRegionValuePairVector;

typedef std::pair<InteractionClassHandle, RegionValueList> InteractionClassHandleRegionValueListPair;

typedef std::pair<AttributeHandle, RegionValueList> AttributeHandleRegionValueListPair;

class AttributeState;
typedef std::vector<AttributeState> AttributeStateVector;

class ParameterValue;
typedef std::vector<ParameterValue> ParameterValueVector;

class AttributeValue;
typedef std::vector<AttributeValue> AttributeValueVector;

typedef std::pair<FederateHandle, SaveStatus> FederateHandleSaveStatusPair;

typedef std::vector<FederateHandleSaveStatusPair> FederateHandleSaveStatusPairVector;

typedef std::pair<FederateHandle, RestoreStatus> FederateHandleRestoreStatusPair;

typedef std::vector<FederateHandleRestoreStatusPair> FederateHandleRestoreStatusPairVector;

class FederationExecutionInformation;
typedef std::vector<FederationExecutionInformation> FederationExecutionInformationVector;

typedef std::pair<ObjectInstanceHandle, String> ObjectInstanceHandleNamePair;

typedef std::vector<ObjectInstanceHandleNamePair> ObjectInstanceHandleNamePairVector;

enum CreateFederationExecutionResponseType {
  CreateFederationExecutionResponseSuccess,
  CreateFederationExecutionResponseFederationExecutionAlreadyExists,
  CreateFederationExecutionResponseCouldNotOpenFDD,
  CreateFederationExecutionResponseErrorReadingFDD,
  CreateFederationExecutionResponseCouldNotCreateLogicalTimeFactory,
  CreateFederationExecutionResponseInconsistentFDD,
  CreateFederationExecutionResponseRTIinternalError
};

enum DestroyFederationExecutionResponseType {
  DestroyFederationExecutionResponseSuccess,
  DestroyFederationExecutionResponseFederatesCurrentlyJoined,
  DestroyFederationExecutionResponseFederationExecutionDoesNotExist,
  DestroyFederationExecutionResponseRTIinternalError
};

enum JoinFederationExecutionResponseType {
  JoinFederationExecutionResponseSuccess,
  JoinFederationExecutionResponseFederateNameAlreadyInUse,
  JoinFederationExecutionResponseFederationExecutionDoesNotExist,
  JoinFederationExecutionResponseSaveInProgress,
  JoinFederationExecutionResponseRestoreInProgress,
  JoinFederationExecutionResponseInconsistentFDD
};

enum RegisterFederationSynchronizationPointResponseType {
  RegisterFederationSynchronizationPointResponseSuccess,
  RegisterFederationSynchronizationPointResponseLabelNotUnique,
  RegisterFederationSynchronizationPointResponseMemberNotJoined
};

typedef std::map<String, StringVector> ConfigurationParameterMap;

class FOMStringTransportationType;
typedef std::vector<FOMStringTransportationType> FOMStringTransportationTypeList;

class FOMStringDimension;
typedef std::vector<FOMStringDimension> FOMStringDimensionList;

class FOMStringRoutingSpace;
typedef std::vector<FOMStringRoutingSpace> FOMStringRoutingSpaceList;

class FOMStringParameter;
typedef std::vector<FOMStringParameter> FOMStringParameterList;

class FOMStringInteractionClass;
typedef std::vector<FOMStringInteractionClass> FOMStringInteractionClassList;

class FOMStringAttribute;
typedef std::vector<FOMStringAttribute> FOMStringAttributeList;

class FOMStringObjectClass;
typedef std::vector<FOMStringObjectClass> FOMStringObjectClassList;

class FOMStringUpdateRate;
typedef std::vector<FOMStringUpdateRate> FOMStringUpdateRateList;

class FOMStringSwitch;
typedef std::vector<FOMStringSwitch> FOMStringSwitchList;

class FOMStringModule;
typedef std::vector<FOMStringModule> FOMStringModuleList;

class FOMTransportationType;
typedef std::vector<FOMTransportationType> FOMTransportationTypeList;

class FOMDimension;
typedef std::vector<FOMDimension> FOMDimensionList;

class FOMRoutingSpace;
typedef std::vector<FOMRoutingSpace> FOMRoutingSpaceList;

class FOMParameter;
typedef std::vector<FOMParameter> FOMParameterList;

class FOMInteractionClass;
typedef std::vector<FOMInteractionClass> FOMInteractionClassList;

class FOMAttribute;
typedef std::vector<FOMAttribute> FOMAttributeList;

class FOMObjectClass;
typedef std::vector<FOMObjectClass> FOMObjectClassList;

class FOMUpdateRate;
typedef std::vector<FOMUpdateRate> FOMUpdateRateList;

class FOMSwitch;
typedef std::vector<FOMSwitch> FOMSwitchList;

class FOMModule;
typedef std::vector<FOMModule> FOMModuleList;

class ConnectionLostMessage;
class CreateFederationExecutionRequestMessage;
class CreateFederationExecutionResponseMessage;
class DestroyFederationExecutionRequestMessage;
class DestroyFederationExecutionResponseMessage;
class EnumerateFederationExecutionsRequestMessage;
class EnumerateFederationExecutionsResponseMessage;
class InsertFederationExecutionMessage;
class ShutdownFederationExecutionMessage;
class EraseFederationExecutionMessage;
class ReleaseFederationHandleMessage;
class InsertModulesMessage;
class JoinFederationExecutionRequestMessage;
class JoinFederationExecutionResponseMessage;
class ResignFederationExecutionLeafRequestMessage;
class ResignFederationExecutionRequestMessage;
class JoinFederateNotifyMessage;
class ResignFederateNotifyMessage;
class ChangeAutomaticResignDirectiveMessage;
class RegisterFederationSynchronizationPointMessage;
class RegisterFederationSynchronizationPointResponseMessage;
class AnnounceSynchronizationPointMessage;
class SynchronizationPointAchievedMessage;
class FederationSynchronizedMessage;
class EnableTimeRegulationRequestMessage;
class EnableTimeRegulationResponseMessage;
class DisableTimeRegulationRequestMessage;
class CommitLowerBoundTimeStampMessage;
class CommitLowerBoundTimeStampResponseMessage;
class LockedByNextMessageRequestMessage;
class TimeConstrainedEnabledMessage;
class TimeRegulationEnabledMessage;
class TimeAdvanceGrantedMessage;
class InsertRegionMessage;
class CommitRegionMessage;
class EraseRegionMessage;
class ChangeInteractionClassPublicationMessage;
class ChangeObjectClassPublicationMessage;
class ChangeInteractionClassSubscriptionMessage;
class ChangeObjectClassSubscriptionMessage;
class RegistrationForObjectClassMessage;
class AttributesInScopeMessage;
class TurnUpdatesOnForInstanceMessage;
class TurnInteractionsOnMessage;
class InteractionMessage;
class TimeStampedInteractionMessage;
class ObjectInstanceHandlesRequestMessage;
class ObjectInstanceHandlesResponseMessage;
class ReleaseMultipleObjectInstanceNameHandlePairsMessage;
class ReserveObjectInstanceNameRequestMessage;
class ReserveObjectInstanceNameResponseMessage;
class ReserveMultipleObjectInstanceNameRequestMessage;
class ReserveMultipleObjectInstanceNameResponseMessage;
class InsertObjectInstanceMessage;
class DeleteObjectInstanceMessage;
class TimeStampedDeleteObjectInstanceMessage;
class AttributeUpdateMessage;
class TimeStampedAttributeUpdateMessage;
class RequestAttributeUpdateMessage;
class RequestClassAttributeUpdateMessage;

typedef bool Bool;

typedef std::string String;

typedef uint32_t Unsigned;

typedef double Double;

typedef std::vector<AttributeHandle> AttributeHandleVector;

typedef std::vector<FederateHandle> FederateHandleVector;

typedef std::vector<ParameterHandle> ParameterHandleVector;

typedef std::vector<DimensionHandle> DimensionHandleVector;

typedef std::set<DimensionHandle> DimensionHandleSet;

typedef std::vector<ObjectInstanceHandle> ObjectInstanceHandleVector;

typedef std::vector<RegionHandle> RegionHandleVector;

typedef std::vector<ModuleHandle> ModuleHandleVector;

typedef std::vector<String> StringVector;

typedef std::set<String> StringSet;

typedef std::pair<FederateHandle, Bool> FederateHandleBoolPair;

typedef std::vector<FederateHandleBoolPair> FederateHandleBoolPairVector;

class OPENRTI_API RangeBoundsValue {
public:
  RangeBoundsValue() :
    _lowerBound(),
    _upperBound()
  { }
  void setLowerBound(const Unsigned& value)
  { _lowerBound = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLowerBound(Unsigned&& value)
  { _lowerBound = std::move(value); }
#endif
  Unsigned& getLowerBound()
  { return _lowerBound; }
  const Unsigned& getLowerBound() const
  { return _lowerBound; }

  void setUpperBound(const Unsigned& value)
  { _upperBound = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setUpperBound(Unsigned&& value)
  { _upperBound = std::move(value); }
#endif
  Unsigned& getUpperBound()
  { return _upperBound; }
  const Unsigned& getUpperBound() const
  { return _upperBound; }

  RangeBoundsValue& swap(RangeBoundsValue& rhs)
  {
    std::swap(_lowerBound, rhs._lowerBound);
    std::swap(_upperBound, rhs._upperBound);
    return *this;
  }
  bool operator==(const RangeBoundsValue& rhs) const
  {
    if (getLowerBound() != rhs.getLowerBound()) return false;
    if (getUpperBound() != rhs.getUpperBound()) return false;
    return true;
  }
  bool operator<(const RangeBoundsValue& rhs) const
  {
    if (getLowerBound() < rhs.getLowerBound()) return true;
    if (rhs.getLowerBound() < getLowerBound()) return false;
    if (getUpperBound() < rhs.getUpperBound()) return true;
    if (rhs.getUpperBound() < getUpperBound()) return false;
    return false;
  }
  bool operator!=(const RangeBoundsValue& rhs) const
  { return !operator==(rhs); }
  bool operator>(const RangeBoundsValue& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const RangeBoundsValue& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const RangeBoundsValue& rhs) const
  { return !operator>(rhs); }
private:
  Unsigned _lowerBound;
  Unsigned _upperBound;
};

typedef std::pair<DimensionHandle, RangeBoundsValue> DimensionHandleRangeBoundsValuePair;

typedef std::vector<DimensionHandleRangeBoundsValuePair> RegionValue;

typedef std::vector<RegionValue> RegionValueList;

typedef std::pair<RegionHandle, DimensionHandleSet> RegionHandleDimensionHandleSetPair;

typedef std::vector<RegionHandleDimensionHandleSetPair> RegionHandleDimensionHandleSetPairVector;

typedef std::pair<RegionHandle, SpaceHandle> RegionHandleSpaceHandlePair;

typedef std::vector<RegionHandleSpaceHandlePair> RegionHandleSpaceHandlePairVector;

typedef std::pair<RegionHandle, RegionValue> RegionHandleRegionValuePair;

typedef std::vector<RegionHandleRegionValuePair> RegionHandleRegionValuePairVector;

typedef std::pair<InteractionClassHandle, RegionValueList> InteractionClassHandleRegionValueListPair;

typedef std::pair<AttributeHandle, RegionValueList> AttributeHandleRegionValueListPair;

class OPENRTI_API AttributeState {
public:
  AttributeState() :
    _attributeHandle()
  { }
  void setAttributeHandle(const AttributeHandle& value)
  { _attributeHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandle(AttributeHandle&& value)
  { _attributeHandle = std::move(value); }
#endif
  AttributeHandle& getAttributeHandle()
  { return _attributeHandle; }
  const AttributeHandle& getAttributeHandle() const
  { return _attributeHandle; }

  AttributeState& swap(AttributeState& rhs)
  {
    std::swap(_attributeHandle, rhs._attributeHandle);
    return *this;
  }
  bool operator==(const AttributeState& rhs) const
  {
    if (getAttributeHandle() != rhs.getAttributeHandle()) return false;
    return true;
  }
  bool operator<(const AttributeState& rhs) const
  {
    if (getAttributeHandle() < rhs.getAttributeHandle()) return true;
    if (rhs.getAttributeHandle() < getAttributeHandle()) return false;
    return false;
  }
  bool operator!=(const AttributeState& rhs) const
  { return !operator==(rhs); }
  bool operator>(const AttributeState& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const AttributeState& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const AttributeState& rhs) const
  { return !operator>(rhs); }
private:
  AttributeHandle _attributeHandle;
};

typedef std::vector<AttributeState> AttributeStateVector;

class OPENRTI_API ParameterValue {
public:
  ParameterValue() :
    _parameterHandle(),
    _value()
  { }
  void setParameterHandle(const ParameterHandle& value)
  { _parameterHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParameterHandle(ParameterHandle&& value)
  { _parameterHandle = std::move(value); }
#endif
  ParameterHandle& getParameterHandle()
  { return _parameterHandle; }
  const ParameterHandle& getParameterHandle() const
  { return _parameterHandle; }

  void setValue(const VariableLengthData& value)
  { _value = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setValue(VariableLengthData&& value)
  { _value = std::move(value); }
#endif
  VariableLengthData& getValue()
  { return _value; }
  const VariableLengthData& getValue() const
  { return _value; }

  ParameterValue& swap(ParameterValue& rhs)
  {
    std::swap(_parameterHandle, rhs._parameterHandle);
    _value.swap(rhs._value);
    return *this;
  }
  bool operator==(const ParameterValue& rhs) const
  {
    if (getParameterHandle() != rhs.getParameterHandle()) return false;
    if (getValue() != rhs.getValue()) return false;
    return true;
  }
  bool operator<(const ParameterValue& rhs) const
  {
    if (getParameterHandle() < rhs.getParameterHandle()) return true;
    if (rhs.getParameterHandle() < getParameterHandle()) return false;
    if (getValue() < rhs.getValue()) return true;
    if (rhs.getValue() < getValue()) return false;
    return false;
  }
  bool operator!=(const ParameterValue& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ParameterValue& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ParameterValue& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ParameterValue& rhs) const
  { return !operator>(rhs); }
private:
  ParameterHandle _parameterHandle;
  VariableLengthData _value;
};

typedef std::vector<ParameterValue> ParameterValueVector;

class OPENRTI_API AttributeValue {
public:
  AttributeValue() :
    _attributeHandle(),
    _value()
  { }
  void setAttributeHandle(const AttributeHandle& value)
  { _attributeHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandle(AttributeHandle&& value)
  { _attributeHandle = std::move(value); }
#endif
  AttributeHandle& getAttributeHandle()
  { return _attributeHandle; }
  const AttributeHandle& getAttributeHandle() const
  { return _attributeHandle; }

  void setValue(const VariableLengthData& value)
  { _value = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setValue(VariableLengthData&& value)
  { _value = std::move(value); }
#endif
  VariableLengthData& getValue()
  { return _value; }
  const VariableLengthData& getValue() const
  { return _value; }

  AttributeValue& swap(AttributeValue& rhs)
  {
    std::swap(_attributeHandle, rhs._attributeHandle);
    _value.swap(rhs._value);
    return *this;
  }
  bool operator==(const AttributeValue& rhs) const
  {
    if (getAttributeHandle() != rhs.getAttributeHandle()) return false;
    if (getValue() != rhs.getValue()) return false;
    return true;
  }
  bool operator<(const AttributeValue& rhs) const
  {
    if (getAttributeHandle() < rhs.getAttributeHandle()) return true;
    if (rhs.getAttributeHandle() < getAttributeHandle()) return false;
    if (getValue() < rhs.getValue()) return true;
    if (rhs.getValue() < getValue()) return false;
    return false;
  }
  bool operator!=(const AttributeValue& rhs) const
  { return !operator==(rhs); }
  bool operator>(const AttributeValue& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const AttributeValue& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const AttributeValue& rhs) const
  { return !operator>(rhs); }
private:
  AttributeHandle _attributeHandle;
  VariableLengthData _value;
};

typedef std::vector<AttributeValue> AttributeValueVector;

typedef std::pair<FederateHandle, SaveStatus> FederateHandleSaveStatusPair;

typedef std::vector<FederateHandleSaveStatusPair> FederateHandleSaveStatusPairVector;

typedef std::pair<FederateHandle, RestoreStatus> FederateHandleRestoreStatusPair;

typedef std::vector<FederateHandleRestoreStatusPair> FederateHandleRestoreStatusPairVector;

class OPENRTI_API FederationExecutionInformation {
public:
  FederationExecutionInformation() :
    _federationExecutionName(),
    _logicalTimeFactoryName()
  { }
  void setFederationExecutionName(const String& value)
  { _federationExecutionName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationExecutionName(String&& value)
  { _federationExecutionName = std::move(value); }
#endif
  String& getFederationExecutionName()
  { return _federationExecutionName; }
  const String& getFederationExecutionName() const
  { return _federationExecutionName; }

  void setLogicalTimeFactoryName(const String& value)
  { _logicalTimeFactoryName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLogicalTimeFactoryName(String&& value)
  { _logicalTimeFactoryName = std::move(value); }
#endif
  String& getLogicalTimeFactoryName()
  { return _logicalTimeFactoryName; }
  const String& getLogicalTimeFactoryName() const
  { return _logicalTimeFactoryName; }

  FederationExecutionInformation& swap(FederationExecutionInformation& rhs)
  {
    _federationExecutionName.swap(rhs._federationExecutionName);
    _logicalTimeFactoryName.swap(rhs._logicalTimeFactoryName);
    return *this;
  }
  bool operator==(const FederationExecutionInformation& rhs) const
  {
    if (getFederationExecutionName() != rhs.getFederationExecutionName()) return false;
    if (getLogicalTimeFactoryName() != rhs.getLogicalTimeFactoryName()) return false;
    return true;
  }
  bool operator<(const FederationExecutionInformation& rhs) const
  {
    if (getFederationExecutionName() < rhs.getFederationExecutionName()) return true;
    if (rhs.getFederationExecutionName() < getFederationExecutionName()) return false;
    if (getLogicalTimeFactoryName() < rhs.getLogicalTimeFactoryName()) return true;
    if (rhs.getLogicalTimeFactoryName() < getLogicalTimeFactoryName()) return false;
    return false;
  }
  bool operator!=(const FederationExecutionInformation& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FederationExecutionInformation& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FederationExecutionInformation& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FederationExecutionInformation& rhs) const
  { return !operator>(rhs); }
private:
  String _federationExecutionName;
  String _logicalTimeFactoryName;
};

typedef std::vector<FederationExecutionInformation> FederationExecutionInformationVector;

typedef std::pair<ObjectInstanceHandle, String> ObjectInstanceHandleNamePair;

typedef std::vector<ObjectInstanceHandleNamePair> ObjectInstanceHandleNamePairVector;

typedef std::map<String, StringVector> ConfigurationParameterMap;

class OPENRTI_API FOMStringTransportationType {
public:
  FOMStringTransportationType() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  FOMStringTransportationType& swap(FOMStringTransportationType& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringTransportationType& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    return true;
  }
  bool operator<(const FOMStringTransportationType& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    return false;
  }
  bool operator!=(const FOMStringTransportationType& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringTransportationType& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringTransportationType& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringTransportationType& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name()
    { }
    String _name;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringTransportationType> FOMStringTransportationTypeList;

class OPENRTI_API FOMStringDimension {
public:
  FOMStringDimension() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setUpperBound(const Unsigned& value)
  { getImpl()._upperBound = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setUpperBound(Unsigned&& value)
  { getImpl()._upperBound = std::move(value); }
#endif
  Unsigned& getUpperBound()
  { return getImpl()._upperBound; }
  const Unsigned& getUpperBound() const
  { return getConstImpl()._upperBound; }

  FOMStringDimension& swap(FOMStringDimension& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringDimension& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getUpperBound() != rhs.getUpperBound()) return false;
    return true;
  }
  bool operator<(const FOMStringDimension& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getUpperBound() < rhs.getUpperBound()) return true;
    if (rhs.getUpperBound() < getUpperBound()) return false;
    return false;
  }
  bool operator!=(const FOMStringDimension& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringDimension& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringDimension& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringDimension& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _upperBound()
    { }
    String _name;
    Unsigned _upperBound;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringDimension> FOMStringDimensionList;

class OPENRTI_API FOMStringRoutingSpace {
public:
  FOMStringRoutingSpace() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setDimensionSet(const StringSet& value)
  { getImpl()._dimensionSet = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionSet(StringSet&& value)
  { getImpl()._dimensionSet = std::move(value); }
#endif
  StringSet& getDimensionSet()
  { return getImpl()._dimensionSet; }
  const StringSet& getDimensionSet() const
  { return getConstImpl()._dimensionSet; }

  FOMStringRoutingSpace& swap(FOMStringRoutingSpace& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringRoutingSpace& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getDimensionSet() != rhs.getDimensionSet()) return false;
    return true;
  }
  bool operator<(const FOMStringRoutingSpace& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getDimensionSet() < rhs.getDimensionSet()) return true;
    if (rhs.getDimensionSet() < getDimensionSet()) return false;
    return false;
  }
  bool operator!=(const FOMStringRoutingSpace& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringRoutingSpace& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringRoutingSpace& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringRoutingSpace& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _dimensionSet()
    { }
    String _name;
    StringSet _dimensionSet;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringRoutingSpace> FOMStringRoutingSpaceList;

class OPENRTI_API FOMStringParameter {
public:
  FOMStringParameter() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  FOMStringParameter& swap(FOMStringParameter& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringParameter& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    return true;
  }
  bool operator<(const FOMStringParameter& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    return false;
  }
  bool operator!=(const FOMStringParameter& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringParameter& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringParameter& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringParameter& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name()
    { }
    String _name;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringParameter> FOMStringParameterList;

class OPENRTI_API FOMStringInteractionClass {
public:
  FOMStringInteractionClass() : 
    _impl(new Implementation())
  { }
  void setName(const StringVector& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(StringVector&& value)
  { getImpl()._name = std::move(value); }
#endif
  StringVector& getName()
  { return getImpl()._name; }
  const StringVector& getName() const
  { return getConstImpl()._name; }

  void setOrderType(const String& value)
  { getImpl()._orderType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOrderType(String&& value)
  { getImpl()._orderType = std::move(value); }
#endif
  String& getOrderType()
  { return getImpl()._orderType; }
  const String& getOrderType() const
  { return getConstImpl()._orderType; }

  void setTransportationType(const String& value)
  { getImpl()._transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(String&& value)
  { getImpl()._transportationType = std::move(value); }
#endif
  String& getTransportationType()
  { return getImpl()._transportationType; }
  const String& getTransportationType() const
  { return getConstImpl()._transportationType; }

  void setRoutingSpace(const String& value)
  { getImpl()._routingSpace = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRoutingSpace(String&& value)
  { getImpl()._routingSpace = std::move(value); }
#endif
  String& getRoutingSpace()
  { return getImpl()._routingSpace; }
  const String& getRoutingSpace() const
  { return getConstImpl()._routingSpace; }

  void setDimensionSet(const StringSet& value)
  { getImpl()._dimensionSet = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionSet(StringSet&& value)
  { getImpl()._dimensionSet = std::move(value); }
#endif
  StringSet& getDimensionSet()
  { return getImpl()._dimensionSet; }
  const StringSet& getDimensionSet() const
  { return getConstImpl()._dimensionSet; }

  void setParameterList(const FOMStringParameterList& value)
  { getImpl()._parameterList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParameterList(FOMStringParameterList&& value)
  { getImpl()._parameterList = std::move(value); }
#endif
  FOMStringParameterList& getParameterList()
  { return getImpl()._parameterList; }
  const FOMStringParameterList& getParameterList() const
  { return getConstImpl()._parameterList; }

  FOMStringInteractionClass& swap(FOMStringInteractionClass& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringInteractionClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getOrderType() != rhs.getOrderType()) return false;
    if (getTransportationType() != rhs.getTransportationType()) return false;
    if (getRoutingSpace() != rhs.getRoutingSpace()) return false;
    if (getDimensionSet() != rhs.getDimensionSet()) return false;
    if (getParameterList() != rhs.getParameterList()) return false;
    return true;
  }
  bool operator<(const FOMStringInteractionClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getOrderType() < rhs.getOrderType()) return true;
    if (rhs.getOrderType() < getOrderType()) return false;
    if (getTransportationType() < rhs.getTransportationType()) return true;
    if (rhs.getTransportationType() < getTransportationType()) return false;
    if (getRoutingSpace() < rhs.getRoutingSpace()) return true;
    if (rhs.getRoutingSpace() < getRoutingSpace()) return false;
    if (getDimensionSet() < rhs.getDimensionSet()) return true;
    if (rhs.getDimensionSet() < getDimensionSet()) return false;
    if (getParameterList() < rhs.getParameterList()) return true;
    if (rhs.getParameterList() < getParameterList()) return false;
    return false;
  }
  bool operator!=(const FOMStringInteractionClass& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringInteractionClass& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringInteractionClass& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringInteractionClass& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _orderType(),
      _transportationType(),
      _routingSpace(),
      _dimensionSet(),
      _parameterList()
    { }
    StringVector _name;
    String _orderType;
    String _transportationType;
    String _routingSpace;
    StringSet _dimensionSet;
    FOMStringParameterList _parameterList;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringInteractionClass> FOMStringInteractionClassList;

class OPENRTI_API FOMStringAttribute {
public:
  FOMStringAttribute() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setOrderType(const String& value)
  { getImpl()._orderType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOrderType(String&& value)
  { getImpl()._orderType = std::move(value); }
#endif
  String& getOrderType()
  { return getImpl()._orderType; }
  const String& getOrderType() const
  { return getConstImpl()._orderType; }

  void setTransportationType(const String& value)
  { getImpl()._transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(String&& value)
  { getImpl()._transportationType = std::move(value); }
#endif
  String& getTransportationType()
  { return getImpl()._transportationType; }
  const String& getTransportationType() const
  { return getConstImpl()._transportationType; }

  void setRoutingSpace(const String& value)
  { getImpl()._routingSpace = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRoutingSpace(String&& value)
  { getImpl()._routingSpace = std::move(value); }
#endif
  String& getRoutingSpace()
  { return getImpl()._routingSpace; }
  const String& getRoutingSpace() const
  { return getConstImpl()._routingSpace; }

  void setDimensionSet(const StringSet& value)
  { getImpl()._dimensionSet = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionSet(StringSet&& value)
  { getImpl()._dimensionSet = std::move(value); }
#endif
  StringSet& getDimensionSet()
  { return getImpl()._dimensionSet; }
  const StringSet& getDimensionSet() const
  { return getConstImpl()._dimensionSet; }

  FOMStringAttribute& swap(FOMStringAttribute& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringAttribute& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getOrderType() != rhs.getOrderType()) return false;
    if (getTransportationType() != rhs.getTransportationType()) return false;
    if (getRoutingSpace() != rhs.getRoutingSpace()) return false;
    if (getDimensionSet() != rhs.getDimensionSet()) return false;
    return true;
  }
  bool operator<(const FOMStringAttribute& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getOrderType() < rhs.getOrderType()) return true;
    if (rhs.getOrderType() < getOrderType()) return false;
    if (getTransportationType() < rhs.getTransportationType()) return true;
    if (rhs.getTransportationType() < getTransportationType()) return false;
    if (getRoutingSpace() < rhs.getRoutingSpace()) return true;
    if (rhs.getRoutingSpace() < getRoutingSpace()) return false;
    if (getDimensionSet() < rhs.getDimensionSet()) return true;
    if (rhs.getDimensionSet() < getDimensionSet()) return false;
    return false;
  }
  bool operator!=(const FOMStringAttribute& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringAttribute& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringAttribute& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringAttribute& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _orderType(),
      _transportationType(),
      _routingSpace(),
      _dimensionSet()
    { }
    String _name;
    String _orderType;
    String _transportationType;
    String _routingSpace;
    StringSet _dimensionSet;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringAttribute> FOMStringAttributeList;

class OPENRTI_API FOMStringObjectClass {
public:
  FOMStringObjectClass() : 
    _impl(new Implementation())
  { }
  void setName(const StringVector& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(StringVector&& value)
  { getImpl()._name = std::move(value); }
#endif
  StringVector& getName()
  { return getImpl()._name; }
  const StringVector& getName() const
  { return getConstImpl()._name; }

  void setAttributeList(const FOMStringAttributeList& value)
  { getImpl()._attributeList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeList(FOMStringAttributeList&& value)
  { getImpl()._attributeList = std::move(value); }
#endif
  FOMStringAttributeList& getAttributeList()
  { return getImpl()._attributeList; }
  const FOMStringAttributeList& getAttributeList() const
  { return getConstImpl()._attributeList; }

  FOMStringObjectClass& swap(FOMStringObjectClass& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringObjectClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getAttributeList() != rhs.getAttributeList()) return false;
    return true;
  }
  bool operator<(const FOMStringObjectClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getAttributeList() < rhs.getAttributeList()) return true;
    if (rhs.getAttributeList() < getAttributeList()) return false;
    return false;
  }
  bool operator!=(const FOMStringObjectClass& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringObjectClass& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringObjectClass& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringObjectClass& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _attributeList()
    { }
    StringVector _name;
    FOMStringAttributeList _attributeList;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringObjectClass> FOMStringObjectClassList;

class OPENRTI_API FOMStringUpdateRate {
public:
  FOMStringUpdateRate() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setRate(const Double& value)
  { getImpl()._rate = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRate(Double&& value)
  { getImpl()._rate = std::move(value); }
#endif
  Double& getRate()
  { return getImpl()._rate; }
  const Double& getRate() const
  { return getConstImpl()._rate; }

  FOMStringUpdateRate& swap(FOMStringUpdateRate& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringUpdateRate& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getRate() != rhs.getRate()) return false;
    return true;
  }
  bool operator<(const FOMStringUpdateRate& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getRate() < rhs.getRate()) return true;
    if (rhs.getRate() < getRate()) return false;
    return false;
  }
  bool operator!=(const FOMStringUpdateRate& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringUpdateRate& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringUpdateRate& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringUpdateRate& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _rate()
    { }
    String _name;
    Double _rate;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringUpdateRate> FOMStringUpdateRateList;

class OPENRTI_API FOMStringSwitch {
public:
  FOMStringSwitch() : 
    _impl(new Implementation())
  { }
  void setSwitchesType(const SwitchesType& value)
  { getImpl()._switchesType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSwitchesType(SwitchesType&& value)
  { getImpl()._switchesType = std::move(value); }
#endif
  SwitchesType& getSwitchesType()
  { return getImpl()._switchesType; }
  const SwitchesType& getSwitchesType() const
  { return getConstImpl()._switchesType; }

  void setEnabled(const Bool& value)
  { getImpl()._enabled = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setEnabled(Bool&& value)
  { getImpl()._enabled = std::move(value); }
#endif
  Bool& getEnabled()
  { return getImpl()._enabled; }
  const Bool& getEnabled() const
  { return getConstImpl()._enabled; }

  FOMStringSwitch& swap(FOMStringSwitch& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringSwitch& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getSwitchesType() != rhs.getSwitchesType()) return false;
    if (getEnabled() != rhs.getEnabled()) return false;
    return true;
  }
  bool operator<(const FOMStringSwitch& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getSwitchesType() < rhs.getSwitchesType()) return true;
    if (rhs.getSwitchesType() < getSwitchesType()) return false;
    if (getEnabled() < rhs.getEnabled()) return true;
    if (rhs.getEnabled() < getEnabled()) return false;
    return false;
  }
  bool operator!=(const FOMStringSwitch& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringSwitch& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringSwitch& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringSwitch& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _switchesType(),
      _enabled()
    { }
    SwitchesType _switchesType;
    Bool _enabled;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringSwitch> FOMStringSwitchList;

class OPENRTI_API FOMStringModule {
public:
  FOMStringModule() : 
    _impl(new Implementation())
  { }
  void setContent(const String& value)
  { getImpl()._content = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setContent(String&& value)
  { getImpl()._content = std::move(value); }
#endif
  String& getContent()
  { return getImpl()._content; }
  const String& getContent() const
  { return getConstImpl()._content; }

  void setTransportationTypeList(const FOMStringTransportationTypeList& value)
  { getImpl()._transportationTypeList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationTypeList(FOMStringTransportationTypeList&& value)
  { getImpl()._transportationTypeList = std::move(value); }
#endif
  FOMStringTransportationTypeList& getTransportationTypeList()
  { return getImpl()._transportationTypeList; }
  const FOMStringTransportationTypeList& getTransportationTypeList() const
  { return getConstImpl()._transportationTypeList; }

  void setDimensionList(const FOMStringDimensionList& value)
  { getImpl()._dimensionList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionList(FOMStringDimensionList&& value)
  { getImpl()._dimensionList = std::move(value); }
#endif
  FOMStringDimensionList& getDimensionList()
  { return getImpl()._dimensionList; }
  const FOMStringDimensionList& getDimensionList() const
  { return getConstImpl()._dimensionList; }

  void setRoutingSpaceList(const FOMStringRoutingSpaceList& value)
  { getImpl()._routingSpaceList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRoutingSpaceList(FOMStringRoutingSpaceList&& value)
  { getImpl()._routingSpaceList = std::move(value); }
#endif
  FOMStringRoutingSpaceList& getRoutingSpaceList()
  { return getImpl()._routingSpaceList; }
  const FOMStringRoutingSpaceList& getRoutingSpaceList() const
  { return getConstImpl()._routingSpaceList; }

  void setInteractionClassList(const FOMStringInteractionClassList& value)
  { getImpl()._interactionClassList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassList(FOMStringInteractionClassList&& value)
  { getImpl()._interactionClassList = std::move(value); }
#endif
  FOMStringInteractionClassList& getInteractionClassList()
  { return getImpl()._interactionClassList; }
  const FOMStringInteractionClassList& getInteractionClassList() const
  { return getConstImpl()._interactionClassList; }

  void setObjectClassList(const FOMStringObjectClassList& value)
  { getImpl()._objectClassList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassList(FOMStringObjectClassList&& value)
  { getImpl()._objectClassList = std::move(value); }
#endif
  FOMStringObjectClassList& getObjectClassList()
  { return getImpl()._objectClassList; }
  const FOMStringObjectClassList& getObjectClassList() const
  { return getConstImpl()._objectClassList; }

  void setUpdateRateList(const FOMStringUpdateRateList& value)
  { getImpl()._updateRateList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setUpdateRateList(FOMStringUpdateRateList&& value)
  { getImpl()._updateRateList = std::move(value); }
#endif
  FOMStringUpdateRateList& getUpdateRateList()
  { return getImpl()._updateRateList; }
  const FOMStringUpdateRateList& getUpdateRateList() const
  { return getConstImpl()._updateRateList; }

  void setSwitchList(const FOMStringSwitchList& value)
  { getImpl()._switchList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSwitchList(FOMStringSwitchList&& value)
  { getImpl()._switchList = std::move(value); }
#endif
  FOMStringSwitchList& getSwitchList()
  { return getImpl()._switchList; }
  const FOMStringSwitchList& getSwitchList() const
  { return getConstImpl()._switchList; }

  void setArtificialInteractionRoot(const Bool& value)
  { getImpl()._artificialInteractionRoot = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setArtificialInteractionRoot(Bool&& value)
  { getImpl()._artificialInteractionRoot = std::move(value); }
#endif
  Bool& getArtificialInteractionRoot()
  { return getImpl()._artificialInteractionRoot; }
  const Bool& getArtificialInteractionRoot() const
  { return getConstImpl()._artificialInteractionRoot; }

  void setArtificialObjectRoot(const Bool& value)
  { getImpl()._artificialObjectRoot = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setArtificialObjectRoot(Bool&& value)
  { getImpl()._artificialObjectRoot = std::move(value); }
#endif
  Bool& getArtificialObjectRoot()
  { return getImpl()._artificialObjectRoot; }
  const Bool& getArtificialObjectRoot() const
  { return getConstImpl()._artificialObjectRoot; }

  FOMStringModule& swap(FOMStringModule& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMStringModule& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getContent() != rhs.getContent()) return false;
    if (getTransportationTypeList() != rhs.getTransportationTypeList()) return false;
    if (getDimensionList() != rhs.getDimensionList()) return false;
    if (getRoutingSpaceList() != rhs.getRoutingSpaceList()) return false;
    if (getInteractionClassList() != rhs.getInteractionClassList()) return false;
    if (getObjectClassList() != rhs.getObjectClassList()) return false;
    if (getUpdateRateList() != rhs.getUpdateRateList()) return false;
    if (getSwitchList() != rhs.getSwitchList()) return false;
    if (getArtificialInteractionRoot() != rhs.getArtificialInteractionRoot()) return false;
    if (getArtificialObjectRoot() != rhs.getArtificialObjectRoot()) return false;
    return true;
  }
  bool operator<(const FOMStringModule& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getContent() < rhs.getContent()) return true;
    if (rhs.getContent() < getContent()) return false;
    if (getTransportationTypeList() < rhs.getTransportationTypeList()) return true;
    if (rhs.getTransportationTypeList() < getTransportationTypeList()) return false;
    if (getDimensionList() < rhs.getDimensionList()) return true;
    if (rhs.getDimensionList() < getDimensionList()) return false;
    if (getRoutingSpaceList() < rhs.getRoutingSpaceList()) return true;
    if (rhs.getRoutingSpaceList() < getRoutingSpaceList()) return false;
    if (getInteractionClassList() < rhs.getInteractionClassList()) return true;
    if (rhs.getInteractionClassList() < getInteractionClassList()) return false;
    if (getObjectClassList() < rhs.getObjectClassList()) return true;
    if (rhs.getObjectClassList() < getObjectClassList()) return false;
    if (getUpdateRateList() < rhs.getUpdateRateList()) return true;
    if (rhs.getUpdateRateList() < getUpdateRateList()) return false;
    if (getSwitchList() < rhs.getSwitchList()) return true;
    if (rhs.getSwitchList() < getSwitchList()) return false;
    if (getArtificialInteractionRoot() < rhs.getArtificialInteractionRoot()) return true;
    if (rhs.getArtificialInteractionRoot() < getArtificialInteractionRoot()) return false;
    if (getArtificialObjectRoot() < rhs.getArtificialObjectRoot()) return true;
    if (rhs.getArtificialObjectRoot() < getArtificialObjectRoot()) return false;
    return false;
  }
  bool operator!=(const FOMStringModule& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMStringModule& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMStringModule& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMStringModule& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _content(),
      _transportationTypeList(),
      _dimensionList(),
      _routingSpaceList(),
      _interactionClassList(),
      _objectClassList(),
      _updateRateList(),
      _switchList(),
      _artificialInteractionRoot(),
      _artificialObjectRoot()
    { }
    String _content;
    FOMStringTransportationTypeList _transportationTypeList;
    FOMStringDimensionList _dimensionList;
    FOMStringRoutingSpaceList _routingSpaceList;
    FOMStringInteractionClassList _interactionClassList;
    FOMStringObjectClassList _objectClassList;
    FOMStringUpdateRateList _updateRateList;
    FOMStringSwitchList _switchList;
    Bool _artificialInteractionRoot;
    Bool _artificialObjectRoot;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMStringModule> FOMStringModuleList;

class OPENRTI_API FOMTransportationType {
public:
  FOMTransportationType() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setTransportationType(const TransportationType& value)
  { getImpl()._transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(TransportationType&& value)
  { getImpl()._transportationType = std::move(value); }
#endif
  TransportationType& getTransportationType()
  { return getImpl()._transportationType; }
  const TransportationType& getTransportationType() const
  { return getConstImpl()._transportationType; }

  FOMTransportationType& swap(FOMTransportationType& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMTransportationType& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getTransportationType() != rhs.getTransportationType()) return false;
    return true;
  }
  bool operator<(const FOMTransportationType& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getTransportationType() < rhs.getTransportationType()) return true;
    if (rhs.getTransportationType() < getTransportationType()) return false;
    return false;
  }
  bool operator!=(const FOMTransportationType& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMTransportationType& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMTransportationType& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMTransportationType& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _transportationType()
    { }
    String _name;
    TransportationType _transportationType;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMTransportationType> FOMTransportationTypeList;

class OPENRTI_API FOMDimension {
public:
  FOMDimension() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setDimensionHandle(const DimensionHandle& value)
  { getImpl()._dimensionHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionHandle(DimensionHandle&& value)
  { getImpl()._dimensionHandle = std::move(value); }
#endif
  DimensionHandle& getDimensionHandle()
  { return getImpl()._dimensionHandle; }
  const DimensionHandle& getDimensionHandle() const
  { return getConstImpl()._dimensionHandle; }

  void setUpperBound(const Unsigned& value)
  { getImpl()._upperBound = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setUpperBound(Unsigned&& value)
  { getImpl()._upperBound = std::move(value); }
#endif
  Unsigned& getUpperBound()
  { return getImpl()._upperBound; }
  const Unsigned& getUpperBound() const
  { return getConstImpl()._upperBound; }

  FOMDimension& swap(FOMDimension& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMDimension& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getDimensionHandle() != rhs.getDimensionHandle()) return false;
    if (getUpperBound() != rhs.getUpperBound()) return false;
    return true;
  }
  bool operator<(const FOMDimension& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getDimensionHandle() < rhs.getDimensionHandle()) return true;
    if (rhs.getDimensionHandle() < getDimensionHandle()) return false;
    if (getUpperBound() < rhs.getUpperBound()) return true;
    if (rhs.getUpperBound() < getUpperBound()) return false;
    return false;
  }
  bool operator!=(const FOMDimension& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMDimension& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMDimension& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMDimension& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _dimensionHandle(),
      _upperBound()
    { }
    String _name;
    DimensionHandle _dimensionHandle;
    Unsigned _upperBound;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMDimension> FOMDimensionList;

class OPENRTI_API FOMRoutingSpace {
public:
  FOMRoutingSpace() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setSpaceHandle(const SpaceHandle& value)
  { getImpl()._spaceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSpaceHandle(SpaceHandle&& value)
  { getImpl()._spaceHandle = std::move(value); }
#endif
  SpaceHandle& getSpaceHandle()
  { return getImpl()._spaceHandle; }
  const SpaceHandle& getSpaceHandle() const
  { return getConstImpl()._spaceHandle; }

  void setDimensionHandleSet(const DimensionHandleSet& value)
  { getImpl()._dimensionHandleSet = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionHandleSet(DimensionHandleSet&& value)
  { getImpl()._dimensionHandleSet = std::move(value); }
#endif
  DimensionHandleSet& getDimensionHandleSet()
  { return getImpl()._dimensionHandleSet; }
  const DimensionHandleSet& getDimensionHandleSet() const
  { return getConstImpl()._dimensionHandleSet; }

  FOMRoutingSpace& swap(FOMRoutingSpace& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMRoutingSpace& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getSpaceHandle() != rhs.getSpaceHandle()) return false;
    if (getDimensionHandleSet() != rhs.getDimensionHandleSet()) return false;
    return true;
  }
  bool operator<(const FOMRoutingSpace& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getSpaceHandle() < rhs.getSpaceHandle()) return true;
    if (rhs.getSpaceHandle() < getSpaceHandle()) return false;
    if (getDimensionHandleSet() < rhs.getDimensionHandleSet()) return true;
    if (rhs.getDimensionHandleSet() < getDimensionHandleSet()) return false;
    return false;
  }
  bool operator!=(const FOMRoutingSpace& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMRoutingSpace& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMRoutingSpace& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMRoutingSpace& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _spaceHandle(),
      _dimensionHandleSet()
    { }
    String _name;
    SpaceHandle _spaceHandle;
    DimensionHandleSet _dimensionHandleSet;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMRoutingSpace> FOMRoutingSpaceList;

class OPENRTI_API FOMParameter {
public:
  FOMParameter() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setParameterHandle(const ParameterHandle& value)
  { getImpl()._parameterHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParameterHandle(ParameterHandle&& value)
  { getImpl()._parameterHandle = std::move(value); }
#endif
  ParameterHandle& getParameterHandle()
  { return getImpl()._parameterHandle; }
  const ParameterHandle& getParameterHandle() const
  { return getConstImpl()._parameterHandle; }

  FOMParameter& swap(FOMParameter& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMParameter& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getParameterHandle() != rhs.getParameterHandle()) return false;
    return true;
  }
  bool operator<(const FOMParameter& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getParameterHandle() < rhs.getParameterHandle()) return true;
    if (rhs.getParameterHandle() < getParameterHandle()) return false;
    return false;
  }
  bool operator!=(const FOMParameter& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMParameter& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMParameter& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMParameter& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _parameterHandle()
    { }
    String _name;
    ParameterHandle _parameterHandle;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMParameter> FOMParameterList;

class OPENRTI_API FOMInteractionClass {
public:
  FOMInteractionClass() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setInteractionClassHandle(const InteractionClassHandle& value)
  { getImpl()._interactionClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassHandle(InteractionClassHandle&& value)
  { getImpl()._interactionClassHandle = std::move(value); }
#endif
  InteractionClassHandle& getInteractionClassHandle()
  { return getImpl()._interactionClassHandle; }
  const InteractionClassHandle& getInteractionClassHandle() const
  { return getConstImpl()._interactionClassHandle; }

  void setParentInteractionClassHandle(const InteractionClassHandle& value)
  { getImpl()._parentInteractionClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParentInteractionClassHandle(InteractionClassHandle&& value)
  { getImpl()._parentInteractionClassHandle = std::move(value); }
#endif
  InteractionClassHandle& getParentInteractionClassHandle()
  { return getImpl()._parentInteractionClassHandle; }
  const InteractionClassHandle& getParentInteractionClassHandle() const
  { return getConstImpl()._parentInteractionClassHandle; }

  void setOrderType(const OrderType& value)
  { getImpl()._orderType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOrderType(OrderType&& value)
  { getImpl()._orderType = std::move(value); }
#endif
  OrderType& getOrderType()
  { return getImpl()._orderType; }
  const OrderType& getOrderType() const
  { return getConstImpl()._orderType; }

  void setTransportationType(const TransportationType& value)
  { getImpl()._transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(TransportationType&& value)
  { getImpl()._transportationType = std::move(value); }
#endif
  TransportationType& getTransportationType()
  { return getImpl()._transportationType; }
  const TransportationType& getTransportationType() const
  { return getConstImpl()._transportationType; }

  void setDimensionHandleSet(const DimensionHandleSet& value)
  { getImpl()._dimensionHandleSet = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionHandleSet(DimensionHandleSet&& value)
  { getImpl()._dimensionHandleSet = std::move(value); }
#endif
  DimensionHandleSet& getDimensionHandleSet()
  { return getImpl()._dimensionHandleSet; }
  const DimensionHandleSet& getDimensionHandleSet() const
  { return getConstImpl()._dimensionHandleSet; }

  void setParameterList(const FOMParameterList& value)
  { getImpl()._parameterList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParameterList(FOMParameterList&& value)
  { getImpl()._parameterList = std::move(value); }
#endif
  FOMParameterList& getParameterList()
  { return getImpl()._parameterList; }
  const FOMParameterList& getParameterList() const
  { return getConstImpl()._parameterList; }

  FOMInteractionClass& swap(FOMInteractionClass& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMInteractionClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getInteractionClassHandle() != rhs.getInteractionClassHandle()) return false;
    if (getParentInteractionClassHandle() != rhs.getParentInteractionClassHandle()) return false;
    if (getOrderType() != rhs.getOrderType()) return false;
    if (getTransportationType() != rhs.getTransportationType()) return false;
    if (getDimensionHandleSet() != rhs.getDimensionHandleSet()) return false;
    if (getParameterList() != rhs.getParameterList()) return false;
    return true;
  }
  bool operator<(const FOMInteractionClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getInteractionClassHandle() < rhs.getInteractionClassHandle()) return true;
    if (rhs.getInteractionClassHandle() < getInteractionClassHandle()) return false;
    if (getParentInteractionClassHandle() < rhs.getParentInteractionClassHandle()) return true;
    if (rhs.getParentInteractionClassHandle() < getParentInteractionClassHandle()) return false;
    if (getOrderType() < rhs.getOrderType()) return true;
    if (rhs.getOrderType() < getOrderType()) return false;
    if (getTransportationType() < rhs.getTransportationType()) return true;
    if (rhs.getTransportationType() < getTransportationType()) return false;
    if (getDimensionHandleSet() < rhs.getDimensionHandleSet()) return true;
    if (rhs.getDimensionHandleSet() < getDimensionHandleSet()) return false;
    if (getParameterList() < rhs.getParameterList()) return true;
    if (rhs.getParameterList() < getParameterList()) return false;
    return false;
  }
  bool operator!=(const FOMInteractionClass& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMInteractionClass& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMInteractionClass& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMInteractionClass& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _interactionClassHandle(),
      _parentInteractionClassHandle(),
      _orderType(),
      _transportationType(),
      _dimensionHandleSet(),
      _parameterList()
    { }
    String _name;
    InteractionClassHandle _interactionClassHandle;
    InteractionClassHandle _parentInteractionClassHandle;
    OrderType _orderType;
    TransportationType _transportationType;
    DimensionHandleSet _dimensionHandleSet;
    FOMParameterList _parameterList;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMInteractionClass> FOMInteractionClassList;

class OPENRTI_API FOMAttribute {
public:
  FOMAttribute() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setAttributeHandle(const AttributeHandle& value)
  { getImpl()._attributeHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandle(AttributeHandle&& value)
  { getImpl()._attributeHandle = std::move(value); }
#endif
  AttributeHandle& getAttributeHandle()
  { return getImpl()._attributeHandle; }
  const AttributeHandle& getAttributeHandle() const
  { return getConstImpl()._attributeHandle; }

  void setOrderType(const OrderType& value)
  { getImpl()._orderType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOrderType(OrderType&& value)
  { getImpl()._orderType = std::move(value); }
#endif
  OrderType& getOrderType()
  { return getImpl()._orderType; }
  const OrderType& getOrderType() const
  { return getConstImpl()._orderType; }

  void setTransportationType(const TransportationType& value)
  { getImpl()._transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(TransportationType&& value)
  { getImpl()._transportationType = std::move(value); }
#endif
  TransportationType& getTransportationType()
  { return getImpl()._transportationType; }
  const TransportationType& getTransportationType() const
  { return getConstImpl()._transportationType; }

  void setDimensionHandleSet(const DimensionHandleSet& value)
  { getImpl()._dimensionHandleSet = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionHandleSet(DimensionHandleSet&& value)
  { getImpl()._dimensionHandleSet = std::move(value); }
#endif
  DimensionHandleSet& getDimensionHandleSet()
  { return getImpl()._dimensionHandleSet; }
  const DimensionHandleSet& getDimensionHandleSet() const
  { return getConstImpl()._dimensionHandleSet; }

  FOMAttribute& swap(FOMAttribute& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMAttribute& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getAttributeHandle() != rhs.getAttributeHandle()) return false;
    if (getOrderType() != rhs.getOrderType()) return false;
    if (getTransportationType() != rhs.getTransportationType()) return false;
    if (getDimensionHandleSet() != rhs.getDimensionHandleSet()) return false;
    return true;
  }
  bool operator<(const FOMAttribute& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getAttributeHandle() < rhs.getAttributeHandle()) return true;
    if (rhs.getAttributeHandle() < getAttributeHandle()) return false;
    if (getOrderType() < rhs.getOrderType()) return true;
    if (rhs.getOrderType() < getOrderType()) return false;
    if (getTransportationType() < rhs.getTransportationType()) return true;
    if (rhs.getTransportationType() < getTransportationType()) return false;
    if (getDimensionHandleSet() < rhs.getDimensionHandleSet()) return true;
    if (rhs.getDimensionHandleSet() < getDimensionHandleSet()) return false;
    return false;
  }
  bool operator!=(const FOMAttribute& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMAttribute& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMAttribute& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMAttribute& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _attributeHandle(),
      _orderType(),
      _transportationType(),
      _dimensionHandleSet()
    { }
    String _name;
    AttributeHandle _attributeHandle;
    OrderType _orderType;
    TransportationType _transportationType;
    DimensionHandleSet _dimensionHandleSet;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMAttribute> FOMAttributeList;

class OPENRTI_API FOMObjectClass {
public:
  FOMObjectClass() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setObjectClassHandle(const ObjectClassHandle& value)
  { getImpl()._objectClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassHandle(ObjectClassHandle&& value)
  { getImpl()._objectClassHandle = std::move(value); }
#endif
  ObjectClassHandle& getObjectClassHandle()
  { return getImpl()._objectClassHandle; }
  const ObjectClassHandle& getObjectClassHandle() const
  { return getConstImpl()._objectClassHandle; }

  void setParentObjectClassHandle(const ObjectClassHandle& value)
  { getImpl()._parentObjectClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParentObjectClassHandle(ObjectClassHandle&& value)
  { getImpl()._parentObjectClassHandle = std::move(value); }
#endif
  ObjectClassHandle& getParentObjectClassHandle()
  { return getImpl()._parentObjectClassHandle; }
  const ObjectClassHandle& getParentObjectClassHandle() const
  { return getConstImpl()._parentObjectClassHandle; }

  void setAttributeList(const FOMAttributeList& value)
  { getImpl()._attributeList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeList(FOMAttributeList&& value)
  { getImpl()._attributeList = std::move(value); }
#endif
  FOMAttributeList& getAttributeList()
  { return getImpl()._attributeList; }
  const FOMAttributeList& getAttributeList() const
  { return getConstImpl()._attributeList; }

  FOMObjectClass& swap(FOMObjectClass& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMObjectClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getObjectClassHandle() != rhs.getObjectClassHandle()) return false;
    if (getParentObjectClassHandle() != rhs.getParentObjectClassHandle()) return false;
    if (getAttributeList() != rhs.getAttributeList()) return false;
    return true;
  }
  bool operator<(const FOMObjectClass& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getObjectClassHandle() < rhs.getObjectClassHandle()) return true;
    if (rhs.getObjectClassHandle() < getObjectClassHandle()) return false;
    if (getParentObjectClassHandle() < rhs.getParentObjectClassHandle()) return true;
    if (rhs.getParentObjectClassHandle() < getParentObjectClassHandle()) return false;
    if (getAttributeList() < rhs.getAttributeList()) return true;
    if (rhs.getAttributeList() < getAttributeList()) return false;
    return false;
  }
  bool operator!=(const FOMObjectClass& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMObjectClass& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMObjectClass& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMObjectClass& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _objectClassHandle(),
      _parentObjectClassHandle(),
      _attributeList()
    { }
    String _name;
    ObjectClassHandle _objectClassHandle;
    ObjectClassHandle _parentObjectClassHandle;
    FOMAttributeList _attributeList;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMObjectClass> FOMObjectClassList;

class OPENRTI_API FOMUpdateRate {
public:
  FOMUpdateRate() : 
    _impl(new Implementation())
  { }
  void setName(const String& value)
  { getImpl()._name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { getImpl()._name = std::move(value); }
#endif
  String& getName()
  { return getImpl()._name; }
  const String& getName() const
  { return getConstImpl()._name; }

  void setUpdateRateHandle(const UpdateRateHandle& value)
  { getImpl()._updateRateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setUpdateRateHandle(UpdateRateHandle&& value)
  { getImpl()._updateRateHandle = std::move(value); }
#endif
  UpdateRateHandle& getUpdateRateHandle()
  { return getImpl()._updateRateHandle; }
  const UpdateRateHandle& getUpdateRateHandle() const
  { return getConstImpl()._updateRateHandle; }

  void setRate(const Double& value)
  { getImpl()._rate = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRate(Double&& value)
  { getImpl()._rate = std::move(value); }
#endif
  Double& getRate()
  { return getImpl()._rate; }
  const Double& getRate() const
  { return getConstImpl()._rate; }

  FOMUpdateRate& swap(FOMUpdateRate& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMUpdateRate& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getName() != rhs.getName()) return false;
    if (getUpdateRateHandle() != rhs.getUpdateRateHandle()) return false;
    if (getRate() != rhs.getRate()) return false;
    return true;
  }
  bool operator<(const FOMUpdateRate& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getName() < rhs.getName()) return true;
    if (rhs.getName() < getName()) return false;
    if (getUpdateRateHandle() < rhs.getUpdateRateHandle()) return true;
    if (rhs.getUpdateRateHandle() < getUpdateRateHandle()) return false;
    if (getRate() < rhs.getRate()) return true;
    if (rhs.getRate() < getRate()) return false;
    return false;
  }
  bool operator!=(const FOMUpdateRate& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMUpdateRate& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMUpdateRate& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMUpdateRate& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _name(),
      _updateRateHandle(),
      _rate()
    { }
    String _name;
    UpdateRateHandle _updateRateHandle;
    Double _rate;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMUpdateRate> FOMUpdateRateList;

class OPENRTI_API FOMSwitch {
public:
  FOMSwitch() : 
    _impl(new Implementation())
  { }
  void setSwitchesType(const SwitchesType& value)
  { getImpl()._switchesType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSwitchesType(SwitchesType&& value)
  { getImpl()._switchesType = std::move(value); }
#endif
  SwitchesType& getSwitchesType()
  { return getImpl()._switchesType; }
  const SwitchesType& getSwitchesType() const
  { return getConstImpl()._switchesType; }

  void setEnabled(const Bool& value)
  { getImpl()._enabled = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setEnabled(Bool&& value)
  { getImpl()._enabled = std::move(value); }
#endif
  Bool& getEnabled()
  { return getImpl()._enabled; }
  const Bool& getEnabled() const
  { return getConstImpl()._enabled; }

  FOMSwitch& swap(FOMSwitch& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMSwitch& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getSwitchesType() != rhs.getSwitchesType()) return false;
    if (getEnabled() != rhs.getEnabled()) return false;
    return true;
  }
  bool operator<(const FOMSwitch& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getSwitchesType() < rhs.getSwitchesType()) return true;
    if (rhs.getSwitchesType() < getSwitchesType()) return false;
    if (getEnabled() < rhs.getEnabled()) return true;
    if (rhs.getEnabled() < getEnabled()) return false;
    return false;
  }
  bool operator!=(const FOMSwitch& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMSwitch& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMSwitch& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMSwitch& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _switchesType(),
      _enabled()
    { }
    SwitchesType _switchesType;
    Bool _enabled;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMSwitch> FOMSwitchList;

class OPENRTI_API FOMModule {
public:
  FOMModule() : 
    _impl(new Implementation())
  { }
  void setModuleHandle(const ModuleHandle& value)
  { getImpl()._moduleHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setModuleHandle(ModuleHandle&& value)
  { getImpl()._moduleHandle = std::move(value); }
#endif
  ModuleHandle& getModuleHandle()
  { return getImpl()._moduleHandle; }
  const ModuleHandle& getModuleHandle() const
  { return getConstImpl()._moduleHandle; }

  void setTransportationTypeList(const FOMTransportationTypeList& value)
  { getImpl()._transportationTypeList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationTypeList(FOMTransportationTypeList&& value)
  { getImpl()._transportationTypeList = std::move(value); }
#endif
  FOMTransportationTypeList& getTransportationTypeList()
  { return getImpl()._transportationTypeList; }
  const FOMTransportationTypeList& getTransportationTypeList() const
  { return getConstImpl()._transportationTypeList; }

  void setDimensionList(const FOMDimensionList& value)
  { getImpl()._dimensionList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDimensionList(FOMDimensionList&& value)
  { getImpl()._dimensionList = std::move(value); }
#endif
  FOMDimensionList& getDimensionList()
  { return getImpl()._dimensionList; }
  const FOMDimensionList& getDimensionList() const
  { return getConstImpl()._dimensionList; }

  void setRoutingSpaceList(const FOMRoutingSpaceList& value)
  { getImpl()._routingSpaceList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRoutingSpaceList(FOMRoutingSpaceList&& value)
  { getImpl()._routingSpaceList = std::move(value); }
#endif
  FOMRoutingSpaceList& getRoutingSpaceList()
  { return getImpl()._routingSpaceList; }
  const FOMRoutingSpaceList& getRoutingSpaceList() const
  { return getConstImpl()._routingSpaceList; }

  void setInteractionClassList(const FOMInteractionClassList& value)
  { getImpl()._interactionClassList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassList(FOMInteractionClassList&& value)
  { getImpl()._interactionClassList = std::move(value); }
#endif
  FOMInteractionClassList& getInteractionClassList()
  { return getImpl()._interactionClassList; }
  const FOMInteractionClassList& getInteractionClassList() const
  { return getConstImpl()._interactionClassList; }

  void setObjectClassList(const FOMObjectClassList& value)
  { getImpl()._objectClassList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassList(FOMObjectClassList&& value)
  { getImpl()._objectClassList = std::move(value); }
#endif
  FOMObjectClassList& getObjectClassList()
  { return getImpl()._objectClassList; }
  const FOMObjectClassList& getObjectClassList() const
  { return getConstImpl()._objectClassList; }

  void setUpdateRateList(const FOMUpdateRateList& value)
  { getImpl()._updateRateList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setUpdateRateList(FOMUpdateRateList&& value)
  { getImpl()._updateRateList = std::move(value); }
#endif
  FOMUpdateRateList& getUpdateRateList()
  { return getImpl()._updateRateList; }
  const FOMUpdateRateList& getUpdateRateList() const
  { return getConstImpl()._updateRateList; }

  void setSwitchList(const FOMSwitchList& value)
  { getImpl()._switchList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSwitchList(FOMSwitchList&& value)
  { getImpl()._switchList = std::move(value); }
#endif
  FOMSwitchList& getSwitchList()
  { return getImpl()._switchList; }
  const FOMSwitchList& getSwitchList() const
  { return getConstImpl()._switchList; }

  void setArtificialInteractionRoot(const Bool& value)
  { getImpl()._artificialInteractionRoot = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setArtificialInteractionRoot(Bool&& value)
  { getImpl()._artificialInteractionRoot = std::move(value); }
#endif
  Bool& getArtificialInteractionRoot()
  { return getImpl()._artificialInteractionRoot; }
  const Bool& getArtificialInteractionRoot() const
  { return getConstImpl()._artificialInteractionRoot; }

  void setArtificialObjectRoot(const Bool& value)
  { getImpl()._artificialObjectRoot = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setArtificialObjectRoot(Bool&& value)
  { getImpl()._artificialObjectRoot = std::move(value); }
#endif
  Bool& getArtificialObjectRoot()
  { return getImpl()._artificialObjectRoot; }
  const Bool& getArtificialObjectRoot() const
  { return getConstImpl()._artificialObjectRoot; }

  void setContent(const String& value)
  { getImpl()._content = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setContent(String&& value)
  { getImpl()._content = std::move(value); }
#endif
  String& getContent()
  { return getImpl()._content; }
  const String& getContent() const
  { return getConstImpl()._content; }

  FOMModule& swap(FOMModule& rhs)
  {
    _impl.swap(rhs._impl);
    return *this;
  }
  bool operator==(const FOMModule& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return true;
    if (getModuleHandle() != rhs.getModuleHandle()) return false;
    if (getTransportationTypeList() != rhs.getTransportationTypeList()) return false;
    if (getDimensionList() != rhs.getDimensionList()) return false;
    if (getRoutingSpaceList() != rhs.getRoutingSpaceList()) return false;
    if (getInteractionClassList() != rhs.getInteractionClassList()) return false;
    if (getObjectClassList() != rhs.getObjectClassList()) return false;
    if (getUpdateRateList() != rhs.getUpdateRateList()) return false;
    if (getSwitchList() != rhs.getSwitchList()) return false;
    if (getArtificialInteractionRoot() != rhs.getArtificialInteractionRoot()) return false;
    if (getArtificialObjectRoot() != rhs.getArtificialObjectRoot()) return false;
    if (getContent() != rhs.getContent()) return false;
    return true;
  }
  bool operator<(const FOMModule& rhs) const
  {
    if (_impl.get() == rhs._impl.get())
      return false;
    if (getModuleHandle() < rhs.getModuleHandle()) return true;
    if (rhs.getModuleHandle() < getModuleHandle()) return false;
    if (getTransportationTypeList() < rhs.getTransportationTypeList()) return true;
    if (rhs.getTransportationTypeList() < getTransportationTypeList()) return false;
    if (getDimensionList() < rhs.getDimensionList()) return true;
    if (rhs.getDimensionList() < getDimensionList()) return false;
    if (getRoutingSpaceList() < rhs.getRoutingSpaceList()) return true;
    if (rhs.getRoutingSpaceList() < getRoutingSpaceList()) return false;
    if (getInteractionClassList() < rhs.getInteractionClassList()) return true;
    if (rhs.getInteractionClassList() < getInteractionClassList()) return false;
    if (getObjectClassList() < rhs.getObjectClassList()) return true;
    if (rhs.getObjectClassList() < getObjectClassList()) return false;
    if (getUpdateRateList() < rhs.getUpdateRateList()) return true;
    if (rhs.getUpdateRateList() < getUpdateRateList()) return false;
    if (getSwitchList() < rhs.getSwitchList()) return true;
    if (rhs.getSwitchList() < getSwitchList()) return false;
    if (getArtificialInteractionRoot() < rhs.getArtificialInteractionRoot()) return true;
    if (rhs.getArtificialInteractionRoot() < getArtificialInteractionRoot()) return false;
    if (getArtificialObjectRoot() < rhs.getArtificialObjectRoot()) return true;
    if (rhs.getArtificialObjectRoot() < getArtificialObjectRoot()) return false;
    if (getContent() < rhs.getContent()) return true;
    if (rhs.getContent() < getContent()) return false;
    return false;
  }
  bool operator!=(const FOMModule& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FOMModule& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FOMModule& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FOMModule& rhs) const
  { return !operator>(rhs); }
private:
  struct OPENRTI_API Implementation : public Referenced {
    Implementation() :
      _moduleHandle(),
      _transportationTypeList(),
      _dimensionList(),
      _routingSpaceList(),
      _interactionClassList(),
      _objectClassList(),
      _updateRateList(),
      _switchList(),
      _artificialInteractionRoot(),
      _artificialObjectRoot(),
      _content()
    { }
    ModuleHandle _moduleHandle;
    FOMTransportationTypeList _transportationTypeList;
    FOMDimensionList _dimensionList;
    FOMRoutingSpaceList _routingSpaceList;
    FOMInteractionClassList _interactionClassList;
    FOMObjectClassList _objectClassList;
    FOMUpdateRateList _updateRateList;
    FOMSwitchList _switchList;
    Bool _artificialInteractionRoot;
    Bool _artificialObjectRoot;
    String _content;
  };

  const Implementation& getConstImpl() const
  {
    return *_impl;
  }

  Implementation& getImpl()
  {
    if (1 < Referenced::count(_impl.get()))
      _impl = new Implementation(*_impl);
    return *_impl;
  }

  SharedPtr<Implementation> _impl;
};

typedef std::vector<FOMModule> FOMModuleList;

class OPENRTI_API ConnectionLostMessage : public AbstractMessage {
public:
  ConnectionLostMessage();
  virtual ~ConnectionLostMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ConnectionLostMessage& rhs) const;
  bool operator<(const ConnectionLostMessage& rhs) const;
  bool operator!=(const ConnectionLostMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ConnectionLostMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ConnectionLostMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ConnectionLostMessage& rhs) const
  { return !operator>(rhs); }

  void setFaultDescription(const String& value)
  { _faultDescription = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFaultDescription(String&& value)
  { _faultDescription = std::move(value); }
#endif
  String& getFaultDescription()
  { return _faultDescription; }
  const String& getFaultDescription() const
  { return _faultDescription; }

private:
  String _faultDescription;
};

class OPENRTI_API CreateFederationExecutionRequestMessage : public AbstractMessage {
public:
  CreateFederationExecutionRequestMessage();
  virtual ~CreateFederationExecutionRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const CreateFederationExecutionRequestMessage& rhs) const;
  bool operator<(const CreateFederationExecutionRequestMessage& rhs) const;
  bool operator!=(const CreateFederationExecutionRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const CreateFederationExecutionRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const CreateFederationExecutionRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const CreateFederationExecutionRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationExecution(const String& value)
  { _federationExecution = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationExecution(String&& value)
  { _federationExecution = std::move(value); }
#endif
  String& getFederationExecution()
  { return _federationExecution; }
  const String& getFederationExecution() const
  { return _federationExecution; }

  void setLogicalTimeFactoryName(const String& value)
  { _logicalTimeFactoryName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLogicalTimeFactoryName(String&& value)
  { _logicalTimeFactoryName = std::move(value); }
#endif
  String& getLogicalTimeFactoryName()
  { return _logicalTimeFactoryName; }
  const String& getLogicalTimeFactoryName() const
  { return _logicalTimeFactoryName; }

  void setFOMStringModuleList(const FOMStringModuleList& value)
  { _fOMStringModuleList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFOMStringModuleList(FOMStringModuleList&& value)
  { _fOMStringModuleList = std::move(value); }
#endif
  FOMStringModuleList& getFOMStringModuleList()
  { return _fOMStringModuleList; }
  const FOMStringModuleList& getFOMStringModuleList() const
  { return _fOMStringModuleList; }

private:
  String _federationExecution;
  String _logicalTimeFactoryName;
  FOMStringModuleList _fOMStringModuleList;
};

class OPENRTI_API CreateFederationExecutionResponseMessage : public AbstractMessage {
public:
  CreateFederationExecutionResponseMessage();
  virtual ~CreateFederationExecutionResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const CreateFederationExecutionResponseMessage& rhs) const;
  bool operator<(const CreateFederationExecutionResponseMessage& rhs) const;
  bool operator!=(const CreateFederationExecutionResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const CreateFederationExecutionResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const CreateFederationExecutionResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const CreateFederationExecutionResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setCreateFederationExecutionResponseType(const CreateFederationExecutionResponseType& value)
  { _createFederationExecutionResponseType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setCreateFederationExecutionResponseType(CreateFederationExecutionResponseType&& value)
  { _createFederationExecutionResponseType = std::move(value); }
#endif
  CreateFederationExecutionResponseType& getCreateFederationExecutionResponseType()
  { return _createFederationExecutionResponseType; }
  const CreateFederationExecutionResponseType& getCreateFederationExecutionResponseType() const
  { return _createFederationExecutionResponseType; }

  void setExceptionString(const String& value)
  { _exceptionString = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setExceptionString(String&& value)
  { _exceptionString = std::move(value); }
#endif
  String& getExceptionString()
  { return _exceptionString; }
  const String& getExceptionString() const
  { return _exceptionString; }

private:
  CreateFederationExecutionResponseType _createFederationExecutionResponseType;
  String _exceptionString;
};

class OPENRTI_API DestroyFederationExecutionRequestMessage : public AbstractMessage {
public:
  DestroyFederationExecutionRequestMessage();
  virtual ~DestroyFederationExecutionRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const DestroyFederationExecutionRequestMessage& rhs) const;
  bool operator<(const DestroyFederationExecutionRequestMessage& rhs) const;
  bool operator!=(const DestroyFederationExecutionRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const DestroyFederationExecutionRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const DestroyFederationExecutionRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const DestroyFederationExecutionRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationExecution(const String& value)
  { _federationExecution = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationExecution(String&& value)
  { _federationExecution = std::move(value); }
#endif
  String& getFederationExecution()
  { return _federationExecution; }
  const String& getFederationExecution() const
  { return _federationExecution; }

private:
  String _federationExecution;
};

class OPENRTI_API DestroyFederationExecutionResponseMessage : public AbstractMessage {
public:
  DestroyFederationExecutionResponseMessage();
  virtual ~DestroyFederationExecutionResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const DestroyFederationExecutionResponseMessage& rhs) const;
  bool operator<(const DestroyFederationExecutionResponseMessage& rhs) const;
  bool operator!=(const DestroyFederationExecutionResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const DestroyFederationExecutionResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const DestroyFederationExecutionResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const DestroyFederationExecutionResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setDestroyFederationExecutionResponseType(const DestroyFederationExecutionResponseType& value)
  { _destroyFederationExecutionResponseType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setDestroyFederationExecutionResponseType(DestroyFederationExecutionResponseType&& value)
  { _destroyFederationExecutionResponseType = std::move(value); }
#endif
  DestroyFederationExecutionResponseType& getDestroyFederationExecutionResponseType()
  { return _destroyFederationExecutionResponseType; }
  const DestroyFederationExecutionResponseType& getDestroyFederationExecutionResponseType() const
  { return _destroyFederationExecutionResponseType; }

private:
  DestroyFederationExecutionResponseType _destroyFederationExecutionResponseType;
};

class OPENRTI_API EnumerateFederationExecutionsRequestMessage : public AbstractMessage {
public:
  EnumerateFederationExecutionsRequestMessage();
  virtual ~EnumerateFederationExecutionsRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const EnumerateFederationExecutionsRequestMessage& rhs) const;
  bool operator<(const EnumerateFederationExecutionsRequestMessage& rhs) const;
  bool operator!=(const EnumerateFederationExecutionsRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const EnumerateFederationExecutionsRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const EnumerateFederationExecutionsRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const EnumerateFederationExecutionsRequestMessage& rhs) const
  { return !operator>(rhs); }

private:
};

class OPENRTI_API EnumerateFederationExecutionsResponseMessage : public AbstractMessage {
public:
  EnumerateFederationExecutionsResponseMessage();
  virtual ~EnumerateFederationExecutionsResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const EnumerateFederationExecutionsResponseMessage& rhs) const;
  bool operator<(const EnumerateFederationExecutionsResponseMessage& rhs) const;
  bool operator!=(const EnumerateFederationExecutionsResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const EnumerateFederationExecutionsResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const EnumerateFederationExecutionsResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const EnumerateFederationExecutionsResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationExecutionInformationVector(const FederationExecutionInformationVector& value)
  { _federationExecutionInformationVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationExecutionInformationVector(FederationExecutionInformationVector&& value)
  { _federationExecutionInformationVector = std::move(value); }
#endif
  FederationExecutionInformationVector& getFederationExecutionInformationVector()
  { return _federationExecutionInformationVector; }
  const FederationExecutionInformationVector& getFederationExecutionInformationVector() const
  { return _federationExecutionInformationVector; }

private:
  FederationExecutionInformationVector _federationExecutionInformationVector;
};

class OPENRTI_API InsertFederationExecutionMessage : public AbstractMessage {
public:
  InsertFederationExecutionMessage();
  virtual ~InsertFederationExecutionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const InsertFederationExecutionMessage& rhs) const;
  bool operator<(const InsertFederationExecutionMessage& rhs) const;
  bool operator!=(const InsertFederationExecutionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const InsertFederationExecutionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const InsertFederationExecutionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const InsertFederationExecutionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederationName(const String& value)
  { _federationName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationName(String&& value)
  { _federationName = std::move(value); }
#endif
  String& getFederationName()
  { return _federationName; }
  const String& getFederationName() const
  { return _federationName; }

  void setLogicalTimeFactoryName(const String& value)
  { _logicalTimeFactoryName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLogicalTimeFactoryName(String&& value)
  { _logicalTimeFactoryName = std::move(value); }
#endif
  String& getLogicalTimeFactoryName()
  { return _logicalTimeFactoryName; }
  const String& getLogicalTimeFactoryName() const
  { return _logicalTimeFactoryName; }

  void setConfigurationParameterMap(const ConfigurationParameterMap& value)
  { _configurationParameterMap = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setConfigurationParameterMap(ConfigurationParameterMap&& value)
  { _configurationParameterMap = std::move(value); }
#endif
  ConfigurationParameterMap& getConfigurationParameterMap()
  { return _configurationParameterMap; }
  const ConfigurationParameterMap& getConfigurationParameterMap() const
  { return _configurationParameterMap; }

private:
  FederationHandle _federationHandle;
  String _federationName;
  String _logicalTimeFactoryName;
  ConfigurationParameterMap _configurationParameterMap;
};

class OPENRTI_API ShutdownFederationExecutionMessage : public AbstractMessage {
public:
  ShutdownFederationExecutionMessage();
  virtual ~ShutdownFederationExecutionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ShutdownFederationExecutionMessage& rhs) const;
  bool operator<(const ShutdownFederationExecutionMessage& rhs) const;
  bool operator!=(const ShutdownFederationExecutionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ShutdownFederationExecutionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ShutdownFederationExecutionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ShutdownFederationExecutionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

private:
  FederationHandle _federationHandle;
};

class OPENRTI_API EraseFederationExecutionMessage : public AbstractMessage {
public:
  EraseFederationExecutionMessage();
  virtual ~EraseFederationExecutionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const EraseFederationExecutionMessage& rhs) const;
  bool operator<(const EraseFederationExecutionMessage& rhs) const;
  bool operator!=(const EraseFederationExecutionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const EraseFederationExecutionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const EraseFederationExecutionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const EraseFederationExecutionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

private:
  FederationHandle _federationHandle;
};

class OPENRTI_API ReleaseFederationHandleMessage : public AbstractMessage {
public:
  ReleaseFederationHandleMessage();
  virtual ~ReleaseFederationHandleMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ReleaseFederationHandleMessage& rhs) const;
  bool operator<(const ReleaseFederationHandleMessage& rhs) const;
  bool operator!=(const ReleaseFederationHandleMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ReleaseFederationHandleMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ReleaseFederationHandleMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ReleaseFederationHandleMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

private:
  FederationHandle _federationHandle;
};

class OPENRTI_API InsertModulesMessage : public AbstractMessage {
public:
  InsertModulesMessage();
  virtual ~InsertModulesMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const InsertModulesMessage& rhs) const;
  bool operator<(const InsertModulesMessage& rhs) const;
  bool operator!=(const InsertModulesMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const InsertModulesMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const InsertModulesMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const InsertModulesMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFOMModuleList(const FOMModuleList& value)
  { _fOMModuleList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFOMModuleList(FOMModuleList&& value)
  { _fOMModuleList = std::move(value); }
#endif
  FOMModuleList& getFOMModuleList()
  { return _fOMModuleList; }
  const FOMModuleList& getFOMModuleList() const
  { return _fOMModuleList; }

private:
  FederationHandle _federationHandle;
  FOMModuleList _fOMModuleList;
};

class OPENRTI_API JoinFederationExecutionRequestMessage : public AbstractMessage {
public:
  JoinFederationExecutionRequestMessage();
  virtual ~JoinFederationExecutionRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const JoinFederationExecutionRequestMessage& rhs) const;
  bool operator<(const JoinFederationExecutionRequestMessage& rhs) const;
  bool operator!=(const JoinFederationExecutionRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const JoinFederationExecutionRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const JoinFederationExecutionRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const JoinFederationExecutionRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationExecution(const String& value)
  { _federationExecution = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationExecution(String&& value)
  { _federationExecution = std::move(value); }
#endif
  String& getFederationExecution()
  { return _federationExecution; }
  const String& getFederationExecution() const
  { return _federationExecution; }

  void setFederateType(const String& value)
  { _federateType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateType(String&& value)
  { _federateType = std::move(value); }
#endif
  String& getFederateType()
  { return _federateType; }
  const String& getFederateType() const
  { return _federateType; }

  void setFederateName(const String& value)
  { _federateName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateName(String&& value)
  { _federateName = std::move(value); }
#endif
  String& getFederateName()
  { return _federateName; }
  const String& getFederateName() const
  { return _federateName; }

  void setFOMStringModuleList(const FOMStringModuleList& value)
  { _fOMStringModuleList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFOMStringModuleList(FOMStringModuleList&& value)
  { _fOMStringModuleList = std::move(value); }
#endif
  FOMStringModuleList& getFOMStringModuleList()
  { return _fOMStringModuleList; }
  const FOMStringModuleList& getFOMStringModuleList() const
  { return _fOMStringModuleList; }

  void setConfigurationParameterMap(const ConfigurationParameterMap& value)
  { _configurationParameterMap = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setConfigurationParameterMap(ConfigurationParameterMap&& value)
  { _configurationParameterMap = std::move(value); }
#endif
  ConfigurationParameterMap& getConfigurationParameterMap()
  { return _configurationParameterMap; }
  const ConfigurationParameterMap& getConfigurationParameterMap() const
  { return _configurationParameterMap; }

private:
  String _federationExecution;
  String _federateType;
  String _federateName;
  FOMStringModuleList _fOMStringModuleList;
  ConfigurationParameterMap _configurationParameterMap;
};

class OPENRTI_API JoinFederationExecutionResponseMessage : public AbstractMessage {
public:
  JoinFederationExecutionResponseMessage();
  virtual ~JoinFederationExecutionResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const JoinFederationExecutionResponseMessage& rhs) const;
  bool operator<(const JoinFederationExecutionResponseMessage& rhs) const;
  bool operator!=(const JoinFederationExecutionResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const JoinFederationExecutionResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const JoinFederationExecutionResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const JoinFederationExecutionResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setJoinFederationExecutionResponseType(const JoinFederationExecutionResponseType& value)
  { _joinFederationExecutionResponseType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setJoinFederationExecutionResponseType(JoinFederationExecutionResponseType&& value)
  { _joinFederationExecutionResponseType = std::move(value); }
#endif
  JoinFederationExecutionResponseType& getJoinFederationExecutionResponseType()
  { return _joinFederationExecutionResponseType; }
  const JoinFederationExecutionResponseType& getJoinFederationExecutionResponseType() const
  { return _joinFederationExecutionResponseType; }

  void setExceptionString(const String& value)
  { _exceptionString = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setExceptionString(String&& value)
  { _exceptionString = std::move(value); }
#endif
  String& getExceptionString()
  { return _exceptionString; }
  const String& getExceptionString() const
  { return _exceptionString; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setFederateType(const String& value)
  { _federateType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateType(String&& value)
  { _federateType = std::move(value); }
#endif
  String& getFederateType()
  { return _federateType; }
  const String& getFederateType() const
  { return _federateType; }

  void setFederateName(const String& value)
  { _federateName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateName(String&& value)
  { _federateName = std::move(value); }
#endif
  String& getFederateName()
  { return _federateName; }
  const String& getFederateName() const
  { return _federateName; }

private:
  FederationHandle _federationHandle;
  JoinFederationExecutionResponseType _joinFederationExecutionResponseType;
  String _exceptionString;
  FederateHandle _federateHandle;
  String _federateType;
  String _federateName;
};

class OPENRTI_API ResignFederationExecutionLeafRequestMessage : public AbstractMessage {
public:
  ResignFederationExecutionLeafRequestMessage();
  virtual ~ResignFederationExecutionLeafRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ResignFederationExecutionLeafRequestMessage& rhs) const;
  bool operator<(const ResignFederationExecutionLeafRequestMessage& rhs) const;
  bool operator!=(const ResignFederationExecutionLeafRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ResignFederationExecutionLeafRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ResignFederationExecutionLeafRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ResignFederationExecutionLeafRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setResignAction(const ResignAction& value)
  { _resignAction = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setResignAction(ResignAction&& value)
  { _resignAction = std::move(value); }
#endif
  ResignAction& getResignAction()
  { return _resignAction; }
  const ResignAction& getResignAction() const
  { return _resignAction; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ResignAction _resignAction;
};

class OPENRTI_API ResignFederationExecutionRequestMessage : public AbstractMessage {
public:
  ResignFederationExecutionRequestMessage();
  virtual ~ResignFederationExecutionRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ResignFederationExecutionRequestMessage& rhs) const;
  bool operator<(const ResignFederationExecutionRequestMessage& rhs) const;
  bool operator!=(const ResignFederationExecutionRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ResignFederationExecutionRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ResignFederationExecutionRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ResignFederationExecutionRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
};

class OPENRTI_API JoinFederateNotifyMessage : public AbstractMessage {
public:
  JoinFederateNotifyMessage();
  virtual ~JoinFederateNotifyMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const JoinFederateNotifyMessage& rhs) const;
  bool operator<(const JoinFederateNotifyMessage& rhs) const;
  bool operator!=(const JoinFederateNotifyMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const JoinFederateNotifyMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const JoinFederateNotifyMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const JoinFederateNotifyMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setFederateType(const String& value)
  { _federateType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateType(String&& value)
  { _federateType = std::move(value); }
#endif
  String& getFederateType()
  { return _federateType; }
  const String& getFederateType() const
  { return _federateType; }

  void setFederateName(const String& value)
  { _federateName = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateName(String&& value)
  { _federateName = std::move(value); }
#endif
  String& getFederateName()
  { return _federateName; }
  const String& getFederateName() const
  { return _federateName; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  String _federateType;
  String _federateName;
};

class OPENRTI_API ResignFederateNotifyMessage : public AbstractMessage {
public:
  ResignFederateNotifyMessage();
  virtual ~ResignFederateNotifyMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ResignFederateNotifyMessage& rhs) const;
  bool operator<(const ResignFederateNotifyMessage& rhs) const;
  bool operator!=(const ResignFederateNotifyMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ResignFederateNotifyMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ResignFederateNotifyMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ResignFederateNotifyMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
};

class OPENRTI_API ChangeAutomaticResignDirectiveMessage : public AbstractMessage {
public:
  ChangeAutomaticResignDirectiveMessage();
  virtual ~ChangeAutomaticResignDirectiveMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ChangeAutomaticResignDirectiveMessage& rhs) const;
  bool operator<(const ChangeAutomaticResignDirectiveMessage& rhs) const;
  bool operator!=(const ChangeAutomaticResignDirectiveMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ChangeAutomaticResignDirectiveMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ChangeAutomaticResignDirectiveMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ChangeAutomaticResignDirectiveMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setResignAction(const ResignAction& value)
  { _resignAction = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setResignAction(ResignAction&& value)
  { _resignAction = std::move(value); }
#endif
  ResignAction& getResignAction()
  { return _resignAction; }
  const ResignAction& getResignAction() const
  { return _resignAction; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ResignAction _resignAction;
};

class OPENRTI_API RegisterFederationSynchronizationPointMessage : public AbstractMessage {
public:
  RegisterFederationSynchronizationPointMessage();
  virtual ~RegisterFederationSynchronizationPointMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const RegisterFederationSynchronizationPointMessage& rhs) const;
  bool operator<(const RegisterFederationSynchronizationPointMessage& rhs) const;
  bool operator!=(const RegisterFederationSynchronizationPointMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const RegisterFederationSynchronizationPointMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const RegisterFederationSynchronizationPointMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const RegisterFederationSynchronizationPointMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setLabel(const String& value)
  { _label = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLabel(String&& value)
  { _label = std::move(value); }
#endif
  String& getLabel()
  { return _label; }
  const String& getLabel() const
  { return _label; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

  void setFederateHandleVector(const FederateHandleVector& value)
  { _federateHandleVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandleVector(FederateHandleVector&& value)
  { _federateHandleVector = std::move(value); }
#endif
  FederateHandleVector& getFederateHandleVector()
  { return _federateHandleVector; }
  const FederateHandleVector& getFederateHandleVector() const
  { return _federateHandleVector; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  String _label;
  VariableLengthData _tag;
  FederateHandleVector _federateHandleVector;
};

class OPENRTI_API RegisterFederationSynchronizationPointResponseMessage : public AbstractMessage {
public:
  RegisterFederationSynchronizationPointResponseMessage();
  virtual ~RegisterFederationSynchronizationPointResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const RegisterFederationSynchronizationPointResponseMessage& rhs) const;
  bool operator<(const RegisterFederationSynchronizationPointResponseMessage& rhs) const;
  bool operator!=(const RegisterFederationSynchronizationPointResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const RegisterFederationSynchronizationPointResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const RegisterFederationSynchronizationPointResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const RegisterFederationSynchronizationPointResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setLabel(const String& value)
  { _label = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLabel(String&& value)
  { _label = std::move(value); }
#endif
  String& getLabel()
  { return _label; }
  const String& getLabel() const
  { return _label; }

  void setRegisterFederationSynchronizationPointResponseType(const RegisterFederationSynchronizationPointResponseType& value)
  { _registerFederationSynchronizationPointResponseType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRegisterFederationSynchronizationPointResponseType(RegisterFederationSynchronizationPointResponseType&& value)
  { _registerFederationSynchronizationPointResponseType = std::move(value); }
#endif
  RegisterFederationSynchronizationPointResponseType& getRegisterFederationSynchronizationPointResponseType()
  { return _registerFederationSynchronizationPointResponseType; }
  const RegisterFederationSynchronizationPointResponseType& getRegisterFederationSynchronizationPointResponseType() const
  { return _registerFederationSynchronizationPointResponseType; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  String _label;
  RegisterFederationSynchronizationPointResponseType _registerFederationSynchronizationPointResponseType;
};

class OPENRTI_API AnnounceSynchronizationPointMessage : public AbstractMessage {
public:
  AnnounceSynchronizationPointMessage();
  virtual ~AnnounceSynchronizationPointMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const AnnounceSynchronizationPointMessage& rhs) const;
  bool operator<(const AnnounceSynchronizationPointMessage& rhs) const;
  bool operator!=(const AnnounceSynchronizationPointMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const AnnounceSynchronizationPointMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const AnnounceSynchronizationPointMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const AnnounceSynchronizationPointMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setLabel(const String& value)
  { _label = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLabel(String&& value)
  { _label = std::move(value); }
#endif
  String& getLabel()
  { return _label; }
  const String& getLabel() const
  { return _label; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

  void setAddJoiningFederates(const Bool& value)
  { _addJoiningFederates = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAddJoiningFederates(Bool&& value)
  { _addJoiningFederates = std::move(value); }
#endif
  Bool& getAddJoiningFederates()
  { return _addJoiningFederates; }
  const Bool& getAddJoiningFederates() const
  { return _addJoiningFederates; }

  void setFederateHandleVector(const FederateHandleVector& value)
  { _federateHandleVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandleVector(FederateHandleVector&& value)
  { _federateHandleVector = std::move(value); }
#endif
  FederateHandleVector& getFederateHandleVector()
  { return _federateHandleVector; }
  const FederateHandleVector& getFederateHandleVector() const
  { return _federateHandleVector; }

private:
  FederationHandle _federationHandle;
  String _label;
  VariableLengthData _tag;
  Bool _addJoiningFederates;
  FederateHandleVector _federateHandleVector;
};

class OPENRTI_API SynchronizationPointAchievedMessage : public AbstractMessage {
public:
  SynchronizationPointAchievedMessage();
  virtual ~SynchronizationPointAchievedMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const SynchronizationPointAchievedMessage& rhs) const;
  bool operator<(const SynchronizationPointAchievedMessage& rhs) const;
  bool operator!=(const SynchronizationPointAchievedMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const SynchronizationPointAchievedMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const SynchronizationPointAchievedMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const SynchronizationPointAchievedMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setLabel(const String& value)
  { _label = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLabel(String&& value)
  { _label = std::move(value); }
#endif
  String& getLabel()
  { return _label; }
  const String& getLabel() const
  { return _label; }

  void setFederateHandleBoolPairVector(const FederateHandleBoolPairVector& value)
  { _federateHandleBoolPairVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandleBoolPairVector(FederateHandleBoolPairVector&& value)
  { _federateHandleBoolPairVector = std::move(value); }
#endif
  FederateHandleBoolPairVector& getFederateHandleBoolPairVector()
  { return _federateHandleBoolPairVector; }
  const FederateHandleBoolPairVector& getFederateHandleBoolPairVector() const
  { return _federateHandleBoolPairVector; }

private:
  FederationHandle _federationHandle;
  String _label;
  FederateHandleBoolPairVector _federateHandleBoolPairVector;
};

class OPENRTI_API FederationSynchronizedMessage : public AbstractMessage {
public:
  FederationSynchronizedMessage();
  virtual ~FederationSynchronizedMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const FederationSynchronizedMessage& rhs) const;
  bool operator<(const FederationSynchronizedMessage& rhs) const;
  bool operator!=(const FederationSynchronizedMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const FederationSynchronizedMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const FederationSynchronizedMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const FederationSynchronizedMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setLabel(const String& value)
  { _label = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLabel(String&& value)
  { _label = std::move(value); }
#endif
  String& getLabel()
  { return _label; }
  const String& getLabel() const
  { return _label; }

  void setFederateHandleBoolPairVector(const FederateHandleBoolPairVector& value)
  { _federateHandleBoolPairVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandleBoolPairVector(FederateHandleBoolPairVector&& value)
  { _federateHandleBoolPairVector = std::move(value); }
#endif
  FederateHandleBoolPairVector& getFederateHandleBoolPairVector()
  { return _federateHandleBoolPairVector; }
  const FederateHandleBoolPairVector& getFederateHandleBoolPairVector() const
  { return _federateHandleBoolPairVector; }

private:
  FederationHandle _federationHandle;
  String _label;
  FederateHandleBoolPairVector _federateHandleBoolPairVector;
};

class OPENRTI_API EnableTimeRegulationRequestMessage : public AbstractMessage {
public:
  EnableTimeRegulationRequestMessage();
  virtual ~EnableTimeRegulationRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const EnableTimeRegulationRequestMessage& rhs) const;
  bool operator<(const EnableTimeRegulationRequestMessage& rhs) const;
  bool operator!=(const EnableTimeRegulationRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const EnableTimeRegulationRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const EnableTimeRegulationRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const EnableTimeRegulationRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setTimeStamp(const VariableLengthData& value)
  { _timeStamp = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTimeStamp(VariableLengthData&& value)
  { _timeStamp = std::move(value); }
#endif
  VariableLengthData& getTimeStamp()
  { return _timeStamp; }
  const VariableLengthData& getTimeStamp() const
  { return _timeStamp; }

  void setCommitId(const Unsigned& value)
  { _commitId = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setCommitId(Unsigned&& value)
  { _commitId = std::move(value); }
#endif
  Unsigned& getCommitId()
  { return _commitId; }
  const Unsigned& getCommitId() const
  { return _commitId; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  VariableLengthData _timeStamp;
  Unsigned _commitId;
};

class OPENRTI_API EnableTimeRegulationResponseMessage : public AbstractMessage {
public:
  EnableTimeRegulationResponseMessage();
  virtual ~EnableTimeRegulationResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const EnableTimeRegulationResponseMessage& rhs) const;
  bool operator<(const EnableTimeRegulationResponseMessage& rhs) const;
  bool operator!=(const EnableTimeRegulationResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const EnableTimeRegulationResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const EnableTimeRegulationResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const EnableTimeRegulationResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setRespondingFederateHandle(const FederateHandle& value)
  { _respondingFederateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRespondingFederateHandle(FederateHandle&& value)
  { _respondingFederateHandle = std::move(value); }
#endif
  FederateHandle& getRespondingFederateHandle()
  { return _respondingFederateHandle; }
  const FederateHandle& getRespondingFederateHandle() const
  { return _respondingFederateHandle; }

  void setTimeStampValid(const Bool& value)
  { _timeStampValid = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTimeStampValid(Bool&& value)
  { _timeStampValid = std::move(value); }
#endif
  Bool& getTimeStampValid()
  { return _timeStampValid; }
  const Bool& getTimeStampValid() const
  { return _timeStampValid; }

  void setTimeStamp(const VariableLengthData& value)
  { _timeStamp = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTimeStamp(VariableLengthData&& value)
  { _timeStamp = std::move(value); }
#endif
  VariableLengthData& getTimeStamp()
  { return _timeStamp; }
  const VariableLengthData& getTimeStamp() const
  { return _timeStamp; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  FederateHandle _respondingFederateHandle;
  Bool _timeStampValid;
  VariableLengthData _timeStamp;
};

class OPENRTI_API DisableTimeRegulationRequestMessage : public AbstractMessage {
public:
  DisableTimeRegulationRequestMessage();
  virtual ~DisableTimeRegulationRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const DisableTimeRegulationRequestMessage& rhs) const;
  bool operator<(const DisableTimeRegulationRequestMessage& rhs) const;
  bool operator!=(const DisableTimeRegulationRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const DisableTimeRegulationRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const DisableTimeRegulationRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const DisableTimeRegulationRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
};

class OPENRTI_API CommitLowerBoundTimeStampMessage : public AbstractMessage {
public:
  CommitLowerBoundTimeStampMessage();
  virtual ~CommitLowerBoundTimeStampMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const CommitLowerBoundTimeStampMessage& rhs) const;
  bool operator<(const CommitLowerBoundTimeStampMessage& rhs) const;
  bool operator!=(const CommitLowerBoundTimeStampMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const CommitLowerBoundTimeStampMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const CommitLowerBoundTimeStampMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const CommitLowerBoundTimeStampMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setTimeStamp(const VariableLengthData& value)
  { _timeStamp = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTimeStamp(VariableLengthData&& value)
  { _timeStamp = std::move(value); }
#endif
  VariableLengthData& getTimeStamp()
  { return _timeStamp; }
  const VariableLengthData& getTimeStamp() const
  { return _timeStamp; }

  void setCommitType(const LowerBoundTimeStampCommitType& value)
  { _commitType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setCommitType(LowerBoundTimeStampCommitType&& value)
  { _commitType = std::move(value); }
#endif
  LowerBoundTimeStampCommitType& getCommitType()
  { return _commitType; }
  const LowerBoundTimeStampCommitType& getCommitType() const
  { return _commitType; }

  void setCommitId(const Unsigned& value)
  { _commitId = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setCommitId(Unsigned&& value)
  { _commitId = std::move(value); }
#endif
  Unsigned& getCommitId()
  { return _commitId; }
  const Unsigned& getCommitId() const
  { return _commitId; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  VariableLengthData _timeStamp;
  LowerBoundTimeStampCommitType _commitType;
  Unsigned _commitId;
};

class OPENRTI_API CommitLowerBoundTimeStampResponseMessage : public AbstractMessage {
public:
  CommitLowerBoundTimeStampResponseMessage();
  virtual ~CommitLowerBoundTimeStampResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const CommitLowerBoundTimeStampResponseMessage& rhs) const;
  bool operator<(const CommitLowerBoundTimeStampResponseMessage& rhs) const;
  bool operator!=(const CommitLowerBoundTimeStampResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const CommitLowerBoundTimeStampResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const CommitLowerBoundTimeStampResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const CommitLowerBoundTimeStampResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setSendingFederateHandle(const FederateHandle& value)
  { _sendingFederateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSendingFederateHandle(FederateHandle&& value)
  { _sendingFederateHandle = std::move(value); }
#endif
  FederateHandle& getSendingFederateHandle()
  { return _sendingFederateHandle; }
  const FederateHandle& getSendingFederateHandle() const
  { return _sendingFederateHandle; }

  void setCommitId(const Unsigned& value)
  { _commitId = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setCommitId(Unsigned&& value)
  { _commitId = std::move(value); }
#endif
  Unsigned& getCommitId()
  { return _commitId; }
  const Unsigned& getCommitId() const
  { return _commitId; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  FederateHandle _sendingFederateHandle;
  Unsigned _commitId;
};

class OPENRTI_API LockedByNextMessageRequestMessage : public AbstractMessage {
public:
  LockedByNextMessageRequestMessage();
  virtual ~LockedByNextMessageRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const LockedByNextMessageRequestMessage& rhs) const;
  bool operator<(const LockedByNextMessageRequestMessage& rhs) const;
  bool operator!=(const LockedByNextMessageRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const LockedByNextMessageRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const LockedByNextMessageRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const LockedByNextMessageRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setSendingFederateHandle(const FederateHandle& value)
  { _sendingFederateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSendingFederateHandle(FederateHandle&& value)
  { _sendingFederateHandle = std::move(value); }
#endif
  FederateHandle& getSendingFederateHandle()
  { return _sendingFederateHandle; }
  const FederateHandle& getSendingFederateHandle() const
  { return _sendingFederateHandle; }

  void setLockedByNextMessage(const Bool& value)
  { _lockedByNextMessage = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setLockedByNextMessage(Bool&& value)
  { _lockedByNextMessage = std::move(value); }
#endif
  Bool& getLockedByNextMessage()
  { return _lockedByNextMessage; }
  const Bool& getLockedByNextMessage() const
  { return _lockedByNextMessage; }

private:
  FederationHandle _federationHandle;
  FederateHandle _sendingFederateHandle;
  Bool _lockedByNextMessage;
};

class OPENRTI_API TimeConstrainedEnabledMessage : public AbstractMessage {
public:
  TimeConstrainedEnabledMessage();
  virtual ~TimeConstrainedEnabledMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TimeConstrainedEnabledMessage& rhs) const;
  bool operator<(const TimeConstrainedEnabledMessage& rhs) const;
  bool operator!=(const TimeConstrainedEnabledMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TimeConstrainedEnabledMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TimeConstrainedEnabledMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TimeConstrainedEnabledMessage& rhs) const
  { return !operator>(rhs); }

private:
};

class OPENRTI_API TimeRegulationEnabledMessage : public AbstractMessage {
public:
  TimeRegulationEnabledMessage();
  virtual ~TimeRegulationEnabledMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TimeRegulationEnabledMessage& rhs) const;
  bool operator<(const TimeRegulationEnabledMessage& rhs) const;
  bool operator!=(const TimeRegulationEnabledMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TimeRegulationEnabledMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TimeRegulationEnabledMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TimeRegulationEnabledMessage& rhs) const
  { return !operator>(rhs); }

private:
};

class OPENRTI_API TimeAdvanceGrantedMessage : public AbstractMessage {
public:
  TimeAdvanceGrantedMessage();
  virtual ~TimeAdvanceGrantedMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TimeAdvanceGrantedMessage& rhs) const;
  bool operator<(const TimeAdvanceGrantedMessage& rhs) const;
  bool operator!=(const TimeAdvanceGrantedMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TimeAdvanceGrantedMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TimeAdvanceGrantedMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TimeAdvanceGrantedMessage& rhs) const
  { return !operator>(rhs); }

private:
};

class OPENRTI_API InsertRegionMessage : public AbstractMessage {
public:
  InsertRegionMessage();
  virtual ~InsertRegionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const InsertRegionMessage& rhs) const;
  bool operator<(const InsertRegionMessage& rhs) const;
  bool operator!=(const InsertRegionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const InsertRegionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const InsertRegionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const InsertRegionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setRegionHandleDimensionHandleSetPairVector(const RegionHandleDimensionHandleSetPairVector& value)
  { _regionHandleDimensionHandleSetPairVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRegionHandleDimensionHandleSetPairVector(RegionHandleDimensionHandleSetPairVector&& value)
  { _regionHandleDimensionHandleSetPairVector = std::move(value); }
#endif
  RegionHandleDimensionHandleSetPairVector& getRegionHandleDimensionHandleSetPairVector()
  { return _regionHandleDimensionHandleSetPairVector; }
  const RegionHandleDimensionHandleSetPairVector& getRegionHandleDimensionHandleSetPairVector() const
  { return _regionHandleDimensionHandleSetPairVector; }

private:
  FederationHandle _federationHandle;
  RegionHandleDimensionHandleSetPairVector _regionHandleDimensionHandleSetPairVector;
};

class OPENRTI_API CommitRegionMessage : public AbstractMessage {
public:
  CommitRegionMessage();
  virtual ~CommitRegionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const CommitRegionMessage& rhs) const;
  bool operator<(const CommitRegionMessage& rhs) const;
  bool operator!=(const CommitRegionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const CommitRegionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const CommitRegionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const CommitRegionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setRegionHandleRegionValuePairVector(const RegionHandleRegionValuePairVector& value)
  { _regionHandleRegionValuePairVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRegionHandleRegionValuePairVector(RegionHandleRegionValuePairVector&& value)
  { _regionHandleRegionValuePairVector = std::move(value); }
#endif
  RegionHandleRegionValuePairVector& getRegionHandleRegionValuePairVector()
  { return _regionHandleRegionValuePairVector; }
  const RegionHandleRegionValuePairVector& getRegionHandleRegionValuePairVector() const
  { return _regionHandleRegionValuePairVector; }

private:
  FederationHandle _federationHandle;
  RegionHandleRegionValuePairVector _regionHandleRegionValuePairVector;
};

class OPENRTI_API EraseRegionMessage : public AbstractMessage {
public:
  EraseRegionMessage();
  virtual ~EraseRegionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const EraseRegionMessage& rhs) const;
  bool operator<(const EraseRegionMessage& rhs) const;
  bool operator!=(const EraseRegionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const EraseRegionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const EraseRegionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const EraseRegionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setRegionHandleVector(const RegionHandleVector& value)
  { _regionHandleVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setRegionHandleVector(RegionHandleVector&& value)
  { _regionHandleVector = std::move(value); }
#endif
  RegionHandleVector& getRegionHandleVector()
  { return _regionHandleVector; }
  const RegionHandleVector& getRegionHandleVector() const
  { return _regionHandleVector; }

private:
  FederationHandle _federationHandle;
  RegionHandleVector _regionHandleVector;
};

class OPENRTI_API ChangeInteractionClassPublicationMessage : public AbstractMessage {
public:
  ChangeInteractionClassPublicationMessage();
  virtual ~ChangeInteractionClassPublicationMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ChangeInteractionClassPublicationMessage& rhs) const;
  bool operator<(const ChangeInteractionClassPublicationMessage& rhs) const;
  bool operator!=(const ChangeInteractionClassPublicationMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ChangeInteractionClassPublicationMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ChangeInteractionClassPublicationMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ChangeInteractionClassPublicationMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setPublicationType(const PublicationType& value)
  { _publicationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setPublicationType(PublicationType&& value)
  { _publicationType = std::move(value); }
#endif
  PublicationType& getPublicationType()
  { return _publicationType; }
  const PublicationType& getPublicationType() const
  { return _publicationType; }

  void setInteractionClassHandle(const InteractionClassHandle& value)
  { _interactionClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassHandle(InteractionClassHandle&& value)
  { _interactionClassHandle = std::move(value); }
#endif
  InteractionClassHandle& getInteractionClassHandle()
  { return _interactionClassHandle; }
  const InteractionClassHandle& getInteractionClassHandle() const
  { return _interactionClassHandle; }

private:
  FederationHandle _federationHandle;
  PublicationType _publicationType;
  InteractionClassHandle _interactionClassHandle;
};

class OPENRTI_API ChangeObjectClassPublicationMessage : public AbstractMessage {
public:
  ChangeObjectClassPublicationMessage();
  virtual ~ChangeObjectClassPublicationMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ChangeObjectClassPublicationMessage& rhs) const;
  bool operator<(const ChangeObjectClassPublicationMessage& rhs) const;
  bool operator!=(const ChangeObjectClassPublicationMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ChangeObjectClassPublicationMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ChangeObjectClassPublicationMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ChangeObjectClassPublicationMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setPublicationType(const PublicationType& value)
  { _publicationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setPublicationType(PublicationType&& value)
  { _publicationType = std::move(value); }
#endif
  PublicationType& getPublicationType()
  { return _publicationType; }
  const PublicationType& getPublicationType() const
  { return _publicationType; }

  void setObjectClassHandle(const ObjectClassHandle& value)
  { _objectClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassHandle(ObjectClassHandle&& value)
  { _objectClassHandle = std::move(value); }
#endif
  ObjectClassHandle& getObjectClassHandle()
  { return _objectClassHandle; }
  const ObjectClassHandle& getObjectClassHandle() const
  { return _objectClassHandle; }

  void setAttributeHandles(const AttributeHandleVector& value)
  { _attributeHandles = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandles(AttributeHandleVector&& value)
  { _attributeHandles = std::move(value); }
#endif
  AttributeHandleVector& getAttributeHandles()
  { return _attributeHandles; }
  const AttributeHandleVector& getAttributeHandles() const
  { return _attributeHandles; }

private:
  FederationHandle _federationHandle;
  PublicationType _publicationType;
  ObjectClassHandle _objectClassHandle;
  AttributeHandleVector _attributeHandles;
};

class OPENRTI_API ChangeInteractionClassSubscriptionMessage : public AbstractMessage {
public:
  ChangeInteractionClassSubscriptionMessage();
  virtual ~ChangeInteractionClassSubscriptionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ChangeInteractionClassSubscriptionMessage& rhs) const;
  bool operator<(const ChangeInteractionClassSubscriptionMessage& rhs) const;
  bool operator!=(const ChangeInteractionClassSubscriptionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ChangeInteractionClassSubscriptionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ChangeInteractionClassSubscriptionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ChangeInteractionClassSubscriptionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setSubscriptionType(const SubscriptionType& value)
  { _subscriptionType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSubscriptionType(SubscriptionType&& value)
  { _subscriptionType = std::move(value); }
#endif
  SubscriptionType& getSubscriptionType()
  { return _subscriptionType; }
  const SubscriptionType& getSubscriptionType() const
  { return _subscriptionType; }

  void setInteractionClassHandle(const InteractionClassHandle& value)
  { _interactionClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassHandle(InteractionClassHandle&& value)
  { _interactionClassHandle = std::move(value); }
#endif
  InteractionClassHandle& getInteractionClassHandle()
  { return _interactionClassHandle; }
  const InteractionClassHandle& getInteractionClassHandle() const
  { return _interactionClassHandle; }

private:
  FederationHandle _federationHandle;
  SubscriptionType _subscriptionType;
  InteractionClassHandle _interactionClassHandle;
};

class OPENRTI_API ChangeObjectClassSubscriptionMessage : public AbstractMessage {
public:
  ChangeObjectClassSubscriptionMessage();
  virtual ~ChangeObjectClassSubscriptionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ChangeObjectClassSubscriptionMessage& rhs) const;
  bool operator<(const ChangeObjectClassSubscriptionMessage& rhs) const;
  bool operator!=(const ChangeObjectClassSubscriptionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ChangeObjectClassSubscriptionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ChangeObjectClassSubscriptionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ChangeObjectClassSubscriptionMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setSubscriptionType(const SubscriptionType& value)
  { _subscriptionType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSubscriptionType(SubscriptionType&& value)
  { _subscriptionType = std::move(value); }
#endif
  SubscriptionType& getSubscriptionType()
  { return _subscriptionType; }
  const SubscriptionType& getSubscriptionType() const
  { return _subscriptionType; }

  void setObjectClassHandle(const ObjectClassHandle& value)
  { _objectClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassHandle(ObjectClassHandle&& value)
  { _objectClassHandle = std::move(value); }
#endif
  ObjectClassHandle& getObjectClassHandle()
  { return _objectClassHandle; }
  const ObjectClassHandle& getObjectClassHandle() const
  { return _objectClassHandle; }

  void setAttributeHandles(const AttributeHandleVector& value)
  { _attributeHandles = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandles(AttributeHandleVector&& value)
  { _attributeHandles = std::move(value); }
#endif
  AttributeHandleVector& getAttributeHandles()
  { return _attributeHandles; }
  const AttributeHandleVector& getAttributeHandles() const
  { return _attributeHandles; }

private:
  FederationHandle _federationHandle;
  SubscriptionType _subscriptionType;
  ObjectClassHandle _objectClassHandle;
  AttributeHandleVector _attributeHandles;
};

class OPENRTI_API RegistrationForObjectClassMessage : public AbstractMessage {
public:
  RegistrationForObjectClassMessage();
  virtual ~RegistrationForObjectClassMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const RegistrationForObjectClassMessage& rhs) const;
  bool operator<(const RegistrationForObjectClassMessage& rhs) const;
  bool operator!=(const RegistrationForObjectClassMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const RegistrationForObjectClassMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const RegistrationForObjectClassMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const RegistrationForObjectClassMessage& rhs) const
  { return !operator>(rhs); }

  void setObjectClassHandle(const ObjectClassHandle& value)
  { _objectClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassHandle(ObjectClassHandle&& value)
  { _objectClassHandle = std::move(value); }
#endif
  ObjectClassHandle& getObjectClassHandle()
  { return _objectClassHandle; }
  const ObjectClassHandle& getObjectClassHandle() const
  { return _objectClassHandle; }

  void setStart(const Bool& value)
  { _start = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setStart(Bool&& value)
  { _start = std::move(value); }
#endif
  Bool& getStart()
  { return _start; }
  const Bool& getStart() const
  { return _start; }

private:
  ObjectClassHandle _objectClassHandle;
  Bool _start;
};

class OPENRTI_API AttributesInScopeMessage : public AbstractMessage {
public:
  AttributesInScopeMessage();
  virtual ~AttributesInScopeMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const AttributesInScopeMessage& rhs) const;
  bool operator<(const AttributesInScopeMessage& rhs) const;
  bool operator!=(const AttributesInScopeMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const AttributesInScopeMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const AttributesInScopeMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const AttributesInScopeMessage& rhs) const
  { return !operator>(rhs); }

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setAttributeHandles(const AttributeHandleVector& value)
  { _attributeHandles = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandles(AttributeHandleVector&& value)
  { _attributeHandles = std::move(value); }
#endif
  AttributeHandleVector& getAttributeHandles()
  { return _attributeHandles; }
  const AttributeHandleVector& getAttributeHandles() const
  { return _attributeHandles; }

  void setInScope(const Bool& value)
  { _inScope = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInScope(Bool&& value)
  { _inScope = std::move(value); }
#endif
  Bool& getInScope()
  { return _inScope; }
  const Bool& getInScope() const
  { return _inScope; }

private:
  ObjectInstanceHandle _objectInstanceHandle;
  AttributeHandleVector _attributeHandles;
  Bool _inScope;
};

class OPENRTI_API TurnUpdatesOnForInstanceMessage : public AbstractMessage {
public:
  TurnUpdatesOnForInstanceMessage();
  virtual ~TurnUpdatesOnForInstanceMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TurnUpdatesOnForInstanceMessage& rhs) const;
  bool operator<(const TurnUpdatesOnForInstanceMessage& rhs) const;
  bool operator!=(const TurnUpdatesOnForInstanceMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TurnUpdatesOnForInstanceMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TurnUpdatesOnForInstanceMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TurnUpdatesOnForInstanceMessage& rhs) const
  { return !operator>(rhs); }

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setAttributeHandles(const AttributeHandleVector& value)
  { _attributeHandles = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandles(AttributeHandleVector&& value)
  { _attributeHandles = std::move(value); }
#endif
  AttributeHandleVector& getAttributeHandles()
  { return _attributeHandles; }
  const AttributeHandleVector& getAttributeHandles() const
  { return _attributeHandles; }

  void setUpdateRate(const String& value)
  { _updateRate = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setUpdateRate(String&& value)
  { _updateRate = std::move(value); }
#endif
  String& getUpdateRate()
  { return _updateRate; }
  const String& getUpdateRate() const
  { return _updateRate; }

  void setOn(const Bool& value)
  { _on = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOn(Bool&& value)
  { _on = std::move(value); }
#endif
  Bool& getOn()
  { return _on; }
  const Bool& getOn() const
  { return _on; }

private:
  ObjectInstanceHandle _objectInstanceHandle;
  AttributeHandleVector _attributeHandles;
  String _updateRate;
  Bool _on;
};

class OPENRTI_API TurnInteractionsOnMessage : public AbstractMessage {
public:
  TurnInteractionsOnMessage();
  virtual ~TurnInteractionsOnMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TurnInteractionsOnMessage& rhs) const;
  bool operator<(const TurnInteractionsOnMessage& rhs) const;
  bool operator!=(const TurnInteractionsOnMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TurnInteractionsOnMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TurnInteractionsOnMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TurnInteractionsOnMessage& rhs) const
  { return !operator>(rhs); }

  void setInteractionClassHandle(const InteractionClassHandle& value)
  { _interactionClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassHandle(InteractionClassHandle&& value)
  { _interactionClassHandle = std::move(value); }
#endif
  InteractionClassHandle& getInteractionClassHandle()
  { return _interactionClassHandle; }
  const InteractionClassHandle& getInteractionClassHandle() const
  { return _interactionClassHandle; }

  void setOn(const Bool& value)
  { _on = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOn(Bool&& value)
  { _on = std::move(value); }
#endif
  Bool& getOn()
  { return _on; }
  const Bool& getOn() const
  { return _on; }

private:
  InteractionClassHandle _interactionClassHandle;
  Bool _on;
};

class OPENRTI_API InteractionMessage : public AbstractMessage {
public:
  InteractionMessage();
  virtual ~InteractionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const InteractionMessage& rhs) const;
  bool operator<(const InteractionMessage& rhs) const;
  bool operator!=(const InteractionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const InteractionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const InteractionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const InteractionMessage& rhs) const
  { return !operator>(rhs); }

  virtual bool getReliable() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setInteractionClassHandle(const InteractionClassHandle& value)
  { _interactionClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassHandle(InteractionClassHandle&& value)
  { _interactionClassHandle = std::move(value); }
#endif
  InteractionClassHandle& getInteractionClassHandle()
  { return _interactionClassHandle; }
  const InteractionClassHandle& getInteractionClassHandle() const
  { return _interactionClassHandle; }

  void setTransportationType(const TransportationType& value)
  { _transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(TransportationType&& value)
  { _transportationType = std::move(value); }
#endif
  TransportationType& getTransportationType()
  { return _transportationType; }
  const TransportationType& getTransportationType() const
  { return _transportationType; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

  void setParameterValues(const ParameterValueVector& value)
  { _parameterValues = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParameterValues(ParameterValueVector&& value)
  { _parameterValues = std::move(value); }
#endif
  ParameterValueVector& getParameterValues()
  { return _parameterValues; }
  const ParameterValueVector& getParameterValues() const
  { return _parameterValues; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  InteractionClassHandle _interactionClassHandle;
  TransportationType _transportationType;
  VariableLengthData _tag;
  ParameterValueVector _parameterValues;
};

class OPENRTI_API TimeStampedInteractionMessage : public AbstractMessage {
public:
  TimeStampedInteractionMessage();
  virtual ~TimeStampedInteractionMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TimeStampedInteractionMessage& rhs) const;
  bool operator<(const TimeStampedInteractionMessage& rhs) const;
  bool operator!=(const TimeStampedInteractionMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TimeStampedInteractionMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TimeStampedInteractionMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TimeStampedInteractionMessage& rhs) const
  { return !operator>(rhs); }

  virtual bool getReliable() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setInteractionClassHandle(const InteractionClassHandle& value)
  { _interactionClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setInteractionClassHandle(InteractionClassHandle&& value)
  { _interactionClassHandle = std::move(value); }
#endif
  InteractionClassHandle& getInteractionClassHandle()
  { return _interactionClassHandle; }
  const InteractionClassHandle& getInteractionClassHandle() const
  { return _interactionClassHandle; }

  void setOrderType(const OrderType& value)
  { _orderType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOrderType(OrderType&& value)
  { _orderType = std::move(value); }
#endif
  OrderType& getOrderType()
  { return _orderType; }
  const OrderType& getOrderType() const
  { return _orderType; }

  void setTransportationType(const TransportationType& value)
  { _transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(TransportationType&& value)
  { _transportationType = std::move(value); }
#endif
  TransportationType& getTransportationType()
  { return _transportationType; }
  const TransportationType& getTransportationType() const
  { return _transportationType; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

  void setTimeStamp(const VariableLengthData& value)
  { _timeStamp = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTimeStamp(VariableLengthData&& value)
  { _timeStamp = std::move(value); }
#endif
  VariableLengthData& getTimeStamp()
  { return _timeStamp; }
  const VariableLengthData& getTimeStamp() const
  { return _timeStamp; }

  void setMessageRetractionHandle(const MessageRetractionHandle& value)
  { _messageRetractionHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setMessageRetractionHandle(MessageRetractionHandle&& value)
  { _messageRetractionHandle = std::move(value); }
#endif
  MessageRetractionHandle& getMessageRetractionHandle()
  { return _messageRetractionHandle; }
  const MessageRetractionHandle& getMessageRetractionHandle() const
  { return _messageRetractionHandle; }

  void setParameterValues(const ParameterValueVector& value)
  { _parameterValues = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setParameterValues(ParameterValueVector&& value)
  { _parameterValues = std::move(value); }
#endif
  ParameterValueVector& getParameterValues()
  { return _parameterValues; }
  const ParameterValueVector& getParameterValues() const
  { return _parameterValues; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  InteractionClassHandle _interactionClassHandle;
  OrderType _orderType;
  TransportationType _transportationType;
  VariableLengthData _tag;
  VariableLengthData _timeStamp;
  MessageRetractionHandle _messageRetractionHandle;
  ParameterValueVector _parameterValues;
};

class OPENRTI_API ObjectInstanceHandlesRequestMessage : public AbstractMessage {
public:
  ObjectInstanceHandlesRequestMessage();
  virtual ~ObjectInstanceHandlesRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ObjectInstanceHandlesRequestMessage& rhs) const;
  bool operator<(const ObjectInstanceHandlesRequestMessage& rhs) const;
  bool operator!=(const ObjectInstanceHandlesRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ObjectInstanceHandlesRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ObjectInstanceHandlesRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ObjectInstanceHandlesRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setCount(const Unsigned& value)
  { _count = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setCount(Unsigned&& value)
  { _count = std::move(value); }
#endif
  Unsigned& getCount()
  { return _count; }
  const Unsigned& getCount() const
  { return _count; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  Unsigned _count;
};

class OPENRTI_API ObjectInstanceHandlesResponseMessage : public AbstractMessage {
public:
  ObjectInstanceHandlesResponseMessage();
  virtual ~ObjectInstanceHandlesResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ObjectInstanceHandlesResponseMessage& rhs) const;
  bool operator<(const ObjectInstanceHandlesResponseMessage& rhs) const;
  bool operator!=(const ObjectInstanceHandlesResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ObjectInstanceHandlesResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ObjectInstanceHandlesResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ObjectInstanceHandlesResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setObjectInstanceHandleNamePairVector(const ObjectInstanceHandleNamePairVector& value)
  { _objectInstanceHandleNamePairVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandleNamePairVector(ObjectInstanceHandleNamePairVector&& value)
  { _objectInstanceHandleNamePairVector = std::move(value); }
#endif
  ObjectInstanceHandleNamePairVector& getObjectInstanceHandleNamePairVector()
  { return _objectInstanceHandleNamePairVector; }
  const ObjectInstanceHandleNamePairVector& getObjectInstanceHandleNamePairVector() const
  { return _objectInstanceHandleNamePairVector; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ObjectInstanceHandleNamePairVector _objectInstanceHandleNamePairVector;
};

class OPENRTI_API ReleaseMultipleObjectInstanceNameHandlePairsMessage : public AbstractMessage {
public:
  ReleaseMultipleObjectInstanceNameHandlePairsMessage();
  virtual ~ReleaseMultipleObjectInstanceNameHandlePairsMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const;
  bool operator<(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const;
  bool operator!=(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ReleaseMultipleObjectInstanceNameHandlePairsMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setObjectInstanceHandleVector(const ObjectInstanceHandleVector& value)
  { _objectInstanceHandleVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandleVector(ObjectInstanceHandleVector&& value)
  { _objectInstanceHandleVector = std::move(value); }
#endif
  ObjectInstanceHandleVector& getObjectInstanceHandleVector()
  { return _objectInstanceHandleVector; }
  const ObjectInstanceHandleVector& getObjectInstanceHandleVector() const
  { return _objectInstanceHandleVector; }

private:
  FederationHandle _federationHandle;
  ObjectInstanceHandleVector _objectInstanceHandleVector;
};

class OPENRTI_API ReserveObjectInstanceNameRequestMessage : public AbstractMessage {
public:
  ReserveObjectInstanceNameRequestMessage();
  virtual ~ReserveObjectInstanceNameRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ReserveObjectInstanceNameRequestMessage& rhs) const;
  bool operator<(const ReserveObjectInstanceNameRequestMessage& rhs) const;
  bool operator!=(const ReserveObjectInstanceNameRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ReserveObjectInstanceNameRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ReserveObjectInstanceNameRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ReserveObjectInstanceNameRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setName(const String& value)
  { _name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { _name = std::move(value); }
#endif
  String& getName()
  { return _name; }
  const String& getName() const
  { return _name; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  String _name;
};

class OPENRTI_API ReserveObjectInstanceNameResponseMessage : public AbstractMessage {
public:
  ReserveObjectInstanceNameResponseMessage();
  virtual ~ReserveObjectInstanceNameResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ReserveObjectInstanceNameResponseMessage& rhs) const;
  bool operator<(const ReserveObjectInstanceNameResponseMessage& rhs) const;
  bool operator!=(const ReserveObjectInstanceNameResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ReserveObjectInstanceNameResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ReserveObjectInstanceNameResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ReserveObjectInstanceNameResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setObjectInstanceHandleNamePair(const ObjectInstanceHandleNamePair& value)
  { _objectInstanceHandleNamePair = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandleNamePair(ObjectInstanceHandleNamePair&& value)
  { _objectInstanceHandleNamePair = std::move(value); }
#endif
  ObjectInstanceHandleNamePair& getObjectInstanceHandleNamePair()
  { return _objectInstanceHandleNamePair; }
  const ObjectInstanceHandleNamePair& getObjectInstanceHandleNamePair() const
  { return _objectInstanceHandleNamePair; }

  void setSuccess(const Bool& value)
  { _success = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSuccess(Bool&& value)
  { _success = std::move(value); }
#endif
  Bool& getSuccess()
  { return _success; }
  const Bool& getSuccess() const
  { return _success; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ObjectInstanceHandleNamePair _objectInstanceHandleNamePair;
  Bool _success;
};

class OPENRTI_API ReserveMultipleObjectInstanceNameRequestMessage : public AbstractMessage {
public:
  ReserveMultipleObjectInstanceNameRequestMessage();
  virtual ~ReserveMultipleObjectInstanceNameRequestMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const;
  bool operator<(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const;
  bool operator!=(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ReserveMultipleObjectInstanceNameRequestMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setNameList(const StringVector& value)
  { _nameList = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setNameList(StringVector&& value)
  { _nameList = std::move(value); }
#endif
  StringVector& getNameList()
  { return _nameList; }
  const StringVector& getNameList() const
  { return _nameList; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  StringVector _nameList;
};

class OPENRTI_API ReserveMultipleObjectInstanceNameResponseMessage : public AbstractMessage {
public:
  ReserveMultipleObjectInstanceNameResponseMessage();
  virtual ~ReserveMultipleObjectInstanceNameResponseMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const;
  bool operator<(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const;
  bool operator!=(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const ReserveMultipleObjectInstanceNameResponseMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setObjectInstanceHandleNamePairVector(const ObjectInstanceHandleNamePairVector& value)
  { _objectInstanceHandleNamePairVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandleNamePairVector(ObjectInstanceHandleNamePairVector&& value)
  { _objectInstanceHandleNamePairVector = std::move(value); }
#endif
  ObjectInstanceHandleNamePairVector& getObjectInstanceHandleNamePairVector()
  { return _objectInstanceHandleNamePairVector; }
  const ObjectInstanceHandleNamePairVector& getObjectInstanceHandleNamePairVector() const
  { return _objectInstanceHandleNamePairVector; }

  void setSuccess(const Bool& value)
  { _success = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setSuccess(Bool&& value)
  { _success = std::move(value); }
#endif
  Bool& getSuccess()
  { return _success; }
  const Bool& getSuccess() const
  { return _success; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ObjectInstanceHandleNamePairVector _objectInstanceHandleNamePairVector;
  Bool _success;
};

class OPENRTI_API InsertObjectInstanceMessage : public AbstractMessage {
public:
  InsertObjectInstanceMessage();
  virtual ~InsertObjectInstanceMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const InsertObjectInstanceMessage& rhs) const;
  bool operator<(const InsertObjectInstanceMessage& rhs) const;
  bool operator!=(const InsertObjectInstanceMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const InsertObjectInstanceMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const InsertObjectInstanceMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const InsertObjectInstanceMessage& rhs) const
  { return !operator>(rhs); }

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setObjectClassHandle(const ObjectClassHandle& value)
  { _objectClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassHandle(ObjectClassHandle&& value)
  { _objectClassHandle = std::move(value); }
#endif
  ObjectClassHandle& getObjectClassHandle()
  { return _objectClassHandle; }
  const ObjectClassHandle& getObjectClassHandle() const
  { return _objectClassHandle; }

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setName(const String& value)
  { _name = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setName(String&& value)
  { _name = std::move(value); }
#endif
  String& getName()
  { return _name; }
  const String& getName() const
  { return _name; }

  void setAttributeStateVector(const AttributeStateVector& value)
  { _attributeStateVector = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeStateVector(AttributeStateVector&& value)
  { _attributeStateVector = std::move(value); }
#endif
  AttributeStateVector& getAttributeStateVector()
  { return _attributeStateVector; }
  const AttributeStateVector& getAttributeStateVector() const
  { return _attributeStateVector; }

private:
  FederationHandle _federationHandle;
  ObjectClassHandle _objectClassHandle;
  ObjectInstanceHandle _objectInstanceHandle;
  String _name;
  AttributeStateVector _attributeStateVector;
};

class OPENRTI_API DeleteObjectInstanceMessage : public AbstractMessage {
public:
  DeleteObjectInstanceMessage();
  virtual ~DeleteObjectInstanceMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const DeleteObjectInstanceMessage& rhs) const;
  bool operator<(const DeleteObjectInstanceMessage& rhs) const;
  bool operator!=(const DeleteObjectInstanceMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const DeleteObjectInstanceMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const DeleteObjectInstanceMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const DeleteObjectInstanceMessage& rhs) const
  { return !operator>(rhs); }

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ObjectInstanceHandle _objectInstanceHandle;
  VariableLengthData _tag;
};

class OPENRTI_API TimeStampedDeleteObjectInstanceMessage : public AbstractMessage {
public:
  TimeStampedDeleteObjectInstanceMessage();
  virtual ~TimeStampedDeleteObjectInstanceMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TimeStampedDeleteObjectInstanceMessage& rhs) const;
  bool operator<(const TimeStampedDeleteObjectInstanceMessage& rhs) const;
  bool operator!=(const TimeStampedDeleteObjectInstanceMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TimeStampedDeleteObjectInstanceMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TimeStampedDeleteObjectInstanceMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TimeStampedDeleteObjectInstanceMessage& rhs) const
  { return !operator>(rhs); }

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setOrderType(const OrderType& value)
  { _orderType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOrderType(OrderType&& value)
  { _orderType = std::move(value); }
#endif
  OrderType& getOrderType()
  { return _orderType; }
  const OrderType& getOrderType() const
  { return _orderType; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

  void setTimeStamp(const VariableLengthData& value)
  { _timeStamp = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTimeStamp(VariableLengthData&& value)
  { _timeStamp = std::move(value); }
#endif
  VariableLengthData& getTimeStamp()
  { return _timeStamp; }
  const VariableLengthData& getTimeStamp() const
  { return _timeStamp; }

  void setMessageRetractionHandle(const MessageRetractionHandle& value)
  { _messageRetractionHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setMessageRetractionHandle(MessageRetractionHandle&& value)
  { _messageRetractionHandle = std::move(value); }
#endif
  MessageRetractionHandle& getMessageRetractionHandle()
  { return _messageRetractionHandle; }
  const MessageRetractionHandle& getMessageRetractionHandle() const
  { return _messageRetractionHandle; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ObjectInstanceHandle _objectInstanceHandle;
  OrderType _orderType;
  VariableLengthData _tag;
  VariableLengthData _timeStamp;
  MessageRetractionHandle _messageRetractionHandle;
};

class OPENRTI_API AttributeUpdateMessage : public AbstractMessage {
public:
  AttributeUpdateMessage();
  virtual ~AttributeUpdateMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const AttributeUpdateMessage& rhs) const;
  bool operator<(const AttributeUpdateMessage& rhs) const;
  bool operator!=(const AttributeUpdateMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const AttributeUpdateMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const AttributeUpdateMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const AttributeUpdateMessage& rhs) const
  { return !operator>(rhs); }

  virtual bool getReliable() const;

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

  void setTransportationType(const TransportationType& value)
  { _transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(TransportationType&& value)
  { _transportationType = std::move(value); }
#endif
  TransportationType& getTransportationType()
  { return _transportationType; }
  const TransportationType& getTransportationType() const
  { return _transportationType; }

  void setAttributeValues(const AttributeValueVector& value)
  { _attributeValues = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeValues(AttributeValueVector&& value)
  { _attributeValues = std::move(value); }
#endif
  AttributeValueVector& getAttributeValues()
  { return _attributeValues; }
  const AttributeValueVector& getAttributeValues() const
  { return _attributeValues; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ObjectInstanceHandle _objectInstanceHandle;
  VariableLengthData _tag;
  TransportationType _transportationType;
  AttributeValueVector _attributeValues;
};

class OPENRTI_API TimeStampedAttributeUpdateMessage : public AbstractMessage {
public:
  TimeStampedAttributeUpdateMessage();
  virtual ~TimeStampedAttributeUpdateMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const TimeStampedAttributeUpdateMessage& rhs) const;
  bool operator<(const TimeStampedAttributeUpdateMessage& rhs) const;
  bool operator!=(const TimeStampedAttributeUpdateMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const TimeStampedAttributeUpdateMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const TimeStampedAttributeUpdateMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const TimeStampedAttributeUpdateMessage& rhs) const
  { return !operator>(rhs); }

  virtual bool getReliable() const;

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setFederateHandle(const FederateHandle& value)
  { _federateHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederateHandle(FederateHandle&& value)
  { _federateHandle = std::move(value); }
#endif
  FederateHandle& getFederateHandle()
  { return _federateHandle; }
  const FederateHandle& getFederateHandle() const
  { return _federateHandle; }

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

  void setTimeStamp(const VariableLengthData& value)
  { _timeStamp = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTimeStamp(VariableLengthData&& value)
  { _timeStamp = std::move(value); }
#endif
  VariableLengthData& getTimeStamp()
  { return _timeStamp; }
  const VariableLengthData& getTimeStamp() const
  { return _timeStamp; }

  void setMessageRetractionHandle(const MessageRetractionHandle& value)
  { _messageRetractionHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setMessageRetractionHandle(MessageRetractionHandle&& value)
  { _messageRetractionHandle = std::move(value); }
#endif
  MessageRetractionHandle& getMessageRetractionHandle()
  { return _messageRetractionHandle; }
  const MessageRetractionHandle& getMessageRetractionHandle() const
  { return _messageRetractionHandle; }

  void setOrderType(const OrderType& value)
  { _orderType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setOrderType(OrderType&& value)
  { _orderType = std::move(value); }
#endif
  OrderType& getOrderType()
  { return _orderType; }
  const OrderType& getOrderType() const
  { return _orderType; }

  void setTransportationType(const TransportationType& value)
  { _transportationType = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTransportationType(TransportationType&& value)
  { _transportationType = std::move(value); }
#endif
  TransportationType& getTransportationType()
  { return _transportationType; }
  const TransportationType& getTransportationType() const
  { return _transportationType; }

  void setAttributeValues(const AttributeValueVector& value)
  { _attributeValues = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeValues(AttributeValueVector&& value)
  { _attributeValues = std::move(value); }
#endif
  AttributeValueVector& getAttributeValues()
  { return _attributeValues; }
  const AttributeValueVector& getAttributeValues() const
  { return _attributeValues; }

private:
  FederationHandle _federationHandle;
  FederateHandle _federateHandle;
  ObjectInstanceHandle _objectInstanceHandle;
  VariableLengthData _tag;
  VariableLengthData _timeStamp;
  MessageRetractionHandle _messageRetractionHandle;
  OrderType _orderType;
  TransportationType _transportationType;
  AttributeValueVector _attributeValues;
};

class OPENRTI_API RequestAttributeUpdateMessage : public AbstractMessage {
public:
  RequestAttributeUpdateMessage();
  virtual ~RequestAttributeUpdateMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const RequestAttributeUpdateMessage& rhs) const;
  bool operator<(const RequestAttributeUpdateMessage& rhs) const;
  bool operator!=(const RequestAttributeUpdateMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const RequestAttributeUpdateMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const RequestAttributeUpdateMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const RequestAttributeUpdateMessage& rhs) const
  { return !operator>(rhs); }

  virtual ObjectInstanceHandle getObjectInstanceHandleForMessage() const;

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setObjectInstanceHandle(const ObjectInstanceHandle& value)
  { _objectInstanceHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectInstanceHandle(ObjectInstanceHandle&& value)
  { _objectInstanceHandle = std::move(value); }
#endif
  ObjectInstanceHandle& getObjectInstanceHandle()
  { return _objectInstanceHandle; }
  const ObjectInstanceHandle& getObjectInstanceHandle() const
  { return _objectInstanceHandle; }

  void setAttributeHandles(const AttributeHandleVector& value)
  { _attributeHandles = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandles(AttributeHandleVector&& value)
  { _attributeHandles = std::move(value); }
#endif
  AttributeHandleVector& getAttributeHandles()
  { return _attributeHandles; }
  const AttributeHandleVector& getAttributeHandles() const
  { return _attributeHandles; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

private:
  FederationHandle _federationHandle;
  ObjectInstanceHandle _objectInstanceHandle;
  AttributeHandleVector _attributeHandles;
  VariableLengthData _tag;
};

class OPENRTI_API RequestClassAttributeUpdateMessage : public AbstractMessage {
public:
  RequestClassAttributeUpdateMessage();
  virtual ~RequestClassAttributeUpdateMessage();

  virtual const char* getTypeName() const;
  virtual void out(std::ostream& os) const;
  virtual void dispatch(const AbstractMessageDispatcher& dispatcher) const;

  virtual bool operator==(const AbstractMessage& rhs) const;
  bool operator==(const RequestClassAttributeUpdateMessage& rhs) const;
  bool operator<(const RequestClassAttributeUpdateMessage& rhs) const;
  bool operator!=(const RequestClassAttributeUpdateMessage& rhs) const
  { return !operator==(rhs); }
  bool operator>(const RequestClassAttributeUpdateMessage& rhs) const
  { return rhs.operator<(*this); }
  bool operator>=(const RequestClassAttributeUpdateMessage& rhs) const
  { return !operator<(rhs); }
  bool operator<=(const RequestClassAttributeUpdateMessage& rhs) const
  { return !operator>(rhs); }

  void setFederationHandle(const FederationHandle& value)
  { _federationHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setFederationHandle(FederationHandle&& value)
  { _federationHandle = std::move(value); }
#endif
  FederationHandle& getFederationHandle()
  { return _federationHandle; }
  const FederationHandle& getFederationHandle() const
  { return _federationHandle; }

  void setObjectClassHandle(const ObjectClassHandle& value)
  { _objectClassHandle = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setObjectClassHandle(ObjectClassHandle&& value)
  { _objectClassHandle = std::move(value); }
#endif
  ObjectClassHandle& getObjectClassHandle()
  { return _objectClassHandle; }
  const ObjectClassHandle& getObjectClassHandle() const
  { return _objectClassHandle; }

  void setAttributeHandles(const AttributeHandleVector& value)
  { _attributeHandles = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setAttributeHandles(AttributeHandleVector&& value)
  { _attributeHandles = std::move(value); }
#endif
  AttributeHandleVector& getAttributeHandles()
  { return _attributeHandles; }
  const AttributeHandleVector& getAttributeHandles() const
  { return _attributeHandles; }

  void setTag(const VariableLengthData& value)
  { _tag = value; }
#if 201103L <= __cplusplus || 200610L <= __cpp_rvalue_reference
  void setTag(VariableLengthData&& value)
  { _tag = std::move(value); }
#endif
  VariableLengthData& getTag()
  { return _tag; }
  const VariableLengthData& getTag() const
  { return _tag; }

private:
  FederationHandle _federationHandle;
  ObjectClassHandle _objectClassHandle;
  AttributeHandleVector _attributeHandles;
  VariableLengthData _tag;
};


template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const CallbackModel& value)
{
  switch (value) {
  case HLA_IMMEDIATE: os << "HLA_IMMEDIATE"; break;
  case HLA_EVOKED: os << "HLA_EVOKED"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const OrderType& value)
{
  switch (value) {
  case RECEIVE: os << "RECEIVE"; break;
  case TIMESTAMP: os << "TIMESTAMP"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TransportationType& value)
{
  switch (value) {
  case RELIABLE: os << "RELIABLE"; break;
  case BEST_EFFORT: os << "BEST_EFFORT"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const SubscriptionType& value)
{
  switch (value) {
  case Unsubscribed: os << "Unsubscribed"; break;
  case SubscribedPassive: os << "SubscribedPassive"; break;
  case SubscribedActive: os << "SubscribedActive"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const PublicationType& value)
{
  switch (value) {
  case Unpublished: os << "Unpublished"; break;
  case Published: os << "Published"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ResignAction& value)
{
  switch (value) {
  case UNCONDITIONALLY_DIVEST_ATTRIBUTES: os << "UNCONDITIONALLY_DIVEST_ATTRIBUTES"; break;
  case DELETE_OBJECTS: os << "DELETE_OBJECTS"; break;
  case CANCEL_PENDING_OWNERSHIP_ACQUISITIONS: os << "CANCEL_PENDING_OWNERSHIP_ACQUISITIONS"; break;
  case DELETE_OBJECTS_THEN_DIVEST: os << "DELETE_OBJECTS_THEN_DIVEST"; break;
  case CANCEL_THEN_DELETE_THEN_DIVEST: os << "CANCEL_THEN_DELETE_THEN_DIVEST"; break;
  case NO_ACTION: os << "NO_ACTION"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RestoreFailureReason& value)
{
  switch (value) {
  case RTI_UNABLE_TO_RESTORE: os << "RTI_UNABLE_TO_RESTORE"; break;
  case FEDERATE_REPORTED_FAILURE_DURING_RESTORE: os << "FEDERATE_REPORTED_FAILURE_DURING_RESTORE"; break;
  case FEDERATE_RESIGNED_DURING_RESTORE: os << "FEDERATE_RESIGNED_DURING_RESTORE"; break;
  case RTI_DETECTED_FAILURE_DURING_RESTORE: os << "RTI_DETECTED_FAILURE_DURING_RESTORE"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RestoreStatus& value)
{
  switch (value) {
  case NO_RESTORE_IN_PROGRESS: os << "NO_RESTORE_IN_PROGRESS"; break;
  case FEDERATE_RESTORE_REQUEST_PENDING: os << "FEDERATE_RESTORE_REQUEST_PENDING"; break;
  case FEDERATE_WAITING_FOR_RESTORE_TO_BEGIN: os << "FEDERATE_WAITING_FOR_RESTORE_TO_BEGIN"; break;
  case FEDERATE_PREPARED_TO_RESTORE: os << "FEDERATE_PREPARED_TO_RESTORE"; break;
  case FEDERATE_RESTORING: os << "FEDERATE_RESTORING"; break;
  case FEDERATE_WAITING_FOR_FEDERATION_TO_RESTORE: os << "FEDERATE_WAITING_FOR_FEDERATION_TO_RESTORE"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const SaveFailureReason& value)
{
  switch (value) {
  case RTI_UNABLE_TO_SAVE: os << "RTI_UNABLE_TO_SAVE"; break;
  case FEDERATE_REPORTED_FAILURE_DURING_SAVE: os << "FEDERATE_REPORTED_FAILURE_DURING_SAVE"; break;
  case FEDERATE_RESIGNED_DURING_SAVE: os << "FEDERATE_RESIGNED_DURING_SAVE"; break;
  case RTI_DETECTED_FAILURE_DURING_SAVE: os << "RTI_DETECTED_FAILURE_DURING_SAVE"; break;
  case SAVE_TIME_CANNOT_BE_HONORED: os << "SAVE_TIME_CANNOT_BE_HONORED"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const SaveStatus& value)
{
  switch (value) {
  case NO_SAVE_IN_PROGRESS: os << "NO_SAVE_IN_PROGRESS"; break;
  case FEDERATE_INSTRUCTED_TO_SAVE: os << "FEDERATE_INSTRUCTED_TO_SAVE"; break;
  case FEDERATE_SAVING: os << "FEDERATE_SAVING"; break;
  case FEDERATE_WAITING_FOR_FEDERATION_TO_SAVE: os << "FEDERATE_WAITING_FOR_FEDERATION_TO_SAVE"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ServiceGroupIndicator& value)
{
  switch (value) {
  case FEDERATION_MANAGEMENT: os << "FEDERATION_MANAGEMENT"; break;
  case DECLARATION_MANAGEMENT: os << "DECLARATION_MANAGEMENT"; break;
  case OBJECT_MANAGEMENT: os << "OBJECT_MANAGEMENT"; break;
  case OWNERSHIP_MANAGEMENT: os << "OWNERSHIP_MANAGEMENT"; break;
  case TIME_MANAGEMENT: os << "TIME_MANAGEMENT"; break;
  case DATA_DISTRIBUTION_MANAGEMENT: os << "DATA_DISTRIBUTION_MANAGEMENT"; break;
  case SUPPORT_SERVICES: os << "SUPPORT_SERVICES"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const LowerBoundTimeStampCommitType& value)
{
  switch (value) {
  case TimeAdvanceCommit: os << "TimeAdvanceCommit"; break;
  case NextMessageCommit: os << "NextMessageCommit"; break;
  case TimeAdvanceAndNextMessageCommit: os << "TimeAdvanceAndNextMessageCommit"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const SwitchesType& value)
{
  switch (value) {
  case InteractionRelevanceAdvisorySwitchesType: os << "InteractionRelevanceAdvisorySwitchesType"; break;
  case ObjectClassRelevanceAdvisorySwitchesType: os << "ObjectClassRelevanceAdvisorySwitchesType"; break;
  case AttributeRelevanceAdvisorySwitchesType: os << "AttributeRelevanceAdvisorySwitchesType"; break;
  case AttributeScopeAdvisorySwitchesType: os << "AttributeScopeAdvisorySwitchesType"; break;
  case AutoProvideSwitchesType: os << "AutoProvideSwitchesType"; break;
  case ConveyRegionDesignatorSetsSwitchesType: os << "ConveyRegionDesignatorSetsSwitchesType"; break;
  case ServiceReportingSwitchesType: os << "ServiceReportingSwitchesType"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributeHandleVector& value)
{
  os << "{ ";
  AttributeHandleVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederateHandleVector& value)
{
  os << "{ ";
  FederateHandleVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ParameterHandleVector& value)
{
  os << "{ ";
  ParameterHandleVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DimensionHandleVector& value)
{
  os << "{ ";
  DimensionHandleVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DimensionHandleSet& value)
{
  os << "{ ";
  DimensionHandleSet::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ObjectInstanceHandleVector& value)
{
  os << "{ ";
  ObjectInstanceHandleVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionHandleVector& value)
{
  os << "{ ";
  RegionHandleVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ModuleHandleVector& value)
{
  os << "{ ";
  ModuleHandleVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const StringVector& value)
{
  os << "{ ";
  StringVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const StringSet& value)
{
  os << "{ ";
  StringSet::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederateHandleBoolPair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederateHandleBoolPairVector& value)
{
  os << "{ ";
  FederateHandleBoolPairVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RangeBoundsValue& value)
{
  os << "{ ";
  os << "lowerBound: " << value.getLowerBound();
  os << ", ";
  os << "upperBound: " << value.getUpperBound();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DimensionHandleRangeBoundsValuePair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionValue& value)
{
  os << "{ ";
  RegionValue::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionValueList& value)
{
  os << "{ ";
  RegionValueList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionHandleDimensionHandleSetPair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionHandleDimensionHandleSetPairVector& value)
{
  os << "{ ";
  RegionHandleDimensionHandleSetPairVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionHandleSpaceHandlePair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionHandleSpaceHandlePairVector& value)
{
  os << "{ ";
  RegionHandleSpaceHandlePairVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionHandleRegionValuePair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegionHandleRegionValuePairVector& value)
{
  os << "{ ";
  RegionHandleRegionValuePairVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const InteractionClassHandleRegionValueListPair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributeHandleRegionValueListPair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributeState& value)
{
  os << "{ ";
  os << "attributeHandle: " << value.getAttributeHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributeStateVector& value)
{
  os << "{ ";
  AttributeStateVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ParameterValue& value)
{
  os << "{ ";
  os << "parameterHandle: " << value.getParameterHandle();
  os << ", ";
  os << "value: " << value.getValue();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ParameterValueVector& value)
{
  os << "{ ";
  ParameterValueVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributeValue& value)
{
  os << "{ ";
  os << "attributeHandle: " << value.getAttributeHandle();
  os << ", ";
  os << "value: " << value.getValue();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributeValueVector& value)
{
  os << "{ ";
  AttributeValueVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederateHandleSaveStatusPair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederateHandleSaveStatusPairVector& value)
{
  os << "{ ";
  FederateHandleSaveStatusPairVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederateHandleRestoreStatusPair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederateHandleRestoreStatusPairVector& value)
{
  os << "{ ";
  FederateHandleRestoreStatusPairVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederationExecutionInformation& value)
{
  os << "{ ";
  os << "federationExecutionName: " << value.getFederationExecutionName();
  os << ", ";
  os << "logicalTimeFactoryName: " << value.getLogicalTimeFactoryName();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederationExecutionInformationVector& value)
{
  os << "{ ";
  FederationExecutionInformationVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ObjectInstanceHandleNamePair& value)
{
  os << "{ ";
  os << "first: " << value.first << ", ";
  os << "second: " << value.second;
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ObjectInstanceHandleNamePairVector& value)
{
  os << "{ ";
  ObjectInstanceHandleNamePairVector::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const CreateFederationExecutionResponseType& value)
{
  switch (value) {
  case CreateFederationExecutionResponseSuccess: os << "CreateFederationExecutionResponseSuccess"; break;
  case CreateFederationExecutionResponseFederationExecutionAlreadyExists: os << "CreateFederationExecutionResponseFederationExecutionAlreadyExists"; break;
  case CreateFederationExecutionResponseCouldNotOpenFDD: os << "CreateFederationExecutionResponseCouldNotOpenFDD"; break;
  case CreateFederationExecutionResponseErrorReadingFDD: os << "CreateFederationExecutionResponseErrorReadingFDD"; break;
  case CreateFederationExecutionResponseCouldNotCreateLogicalTimeFactory: os << "CreateFederationExecutionResponseCouldNotCreateLogicalTimeFactory"; break;
  case CreateFederationExecutionResponseInconsistentFDD: os << "CreateFederationExecutionResponseInconsistentFDD"; break;
  case CreateFederationExecutionResponseRTIinternalError: os << "CreateFederationExecutionResponseRTIinternalError"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DestroyFederationExecutionResponseType& value)
{
  switch (value) {
  case DestroyFederationExecutionResponseSuccess: os << "DestroyFederationExecutionResponseSuccess"; break;
  case DestroyFederationExecutionResponseFederatesCurrentlyJoined: os << "DestroyFederationExecutionResponseFederatesCurrentlyJoined"; break;
  case DestroyFederationExecutionResponseFederationExecutionDoesNotExist: os << "DestroyFederationExecutionResponseFederationExecutionDoesNotExist"; break;
  case DestroyFederationExecutionResponseRTIinternalError: os << "DestroyFederationExecutionResponseRTIinternalError"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const JoinFederationExecutionResponseType& value)
{
  switch (value) {
  case JoinFederationExecutionResponseSuccess: os << "JoinFederationExecutionResponseSuccess"; break;
  case JoinFederationExecutionResponseFederateNameAlreadyInUse: os << "JoinFederationExecutionResponseFederateNameAlreadyInUse"; break;
  case JoinFederationExecutionResponseFederationExecutionDoesNotExist: os << "JoinFederationExecutionResponseFederationExecutionDoesNotExist"; break;
  case JoinFederationExecutionResponseSaveInProgress: os << "JoinFederationExecutionResponseSaveInProgress"; break;
  case JoinFederationExecutionResponseRestoreInProgress: os << "JoinFederationExecutionResponseRestoreInProgress"; break;
  case JoinFederationExecutionResponseInconsistentFDD: os << "JoinFederationExecutionResponseInconsistentFDD"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegisterFederationSynchronizationPointResponseType& value)
{
  switch (value) {
  case RegisterFederationSynchronizationPointResponseSuccess: os << "RegisterFederationSynchronizationPointResponseSuccess"; break;
  case RegisterFederationSynchronizationPointResponseLabelNotUnique: os << "RegisterFederationSynchronizationPointResponseLabelNotUnique"; break;
  case RegisterFederationSynchronizationPointResponseMemberNotJoined: os << "RegisterFederationSynchronizationPointResponseMemberNotJoined"; break;
  }
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ConfigurationParameterMap& value)
{
  os << "{ ";
  ConfigurationParameterMap::const_iterator i = value.begin();
  if (i != value.end()) {
    os << i->first << ": " << i->second;
    while (++i != value.end()) {
      os << ", " << i->first << ": " << i->second;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringTransportationType& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringTransportationTypeList& value)
{
  os << "{ ";
  FOMStringTransportationTypeList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringDimension& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "upperBound: " << value.getUpperBound();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringDimensionList& value)
{
  os << "{ ";
  FOMStringDimensionList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringRoutingSpace& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "dimensionSet: " << value.getDimensionSet();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringRoutingSpaceList& value)
{
  os << "{ ";
  FOMStringRoutingSpaceList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringParameter& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringParameterList& value)
{
  os << "{ ";
  FOMStringParameterList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringInteractionClass& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "orderType: " << value.getOrderType();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "routingSpace: " << value.getRoutingSpace();
  os << ", ";
  os << "dimensionSet: " << value.getDimensionSet();
  os << ", ";
  os << "parameterList: " << value.getParameterList();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringInteractionClassList& value)
{
  os << "{ ";
  FOMStringInteractionClassList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringAttribute& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "orderType: " << value.getOrderType();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "routingSpace: " << value.getRoutingSpace();
  os << ", ";
  os << "dimensionSet: " << value.getDimensionSet();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringAttributeList& value)
{
  os << "{ ";
  FOMStringAttributeList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringObjectClass& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "attributeList: " << value.getAttributeList();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringObjectClassList& value)
{
  os << "{ ";
  FOMStringObjectClassList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringUpdateRate& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "rate: " << value.getRate();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringUpdateRateList& value)
{
  os << "{ ";
  FOMStringUpdateRateList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringSwitch& value)
{
  os << "{ ";
  os << "switchesType: " << value.getSwitchesType();
  os << ", ";
  os << "enabled: " << value.getEnabled();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringSwitchList& value)
{
  os << "{ ";
  FOMStringSwitchList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringModule& value)
{
  os << "{ ";
  os << "content: " << value.getContent();
  os << ", ";
  os << "transportationTypeList: " << value.getTransportationTypeList();
  os << ", ";
  os << "dimensionList: " << value.getDimensionList();
  os << ", ";
  os << "routingSpaceList: " << value.getRoutingSpaceList();
  os << ", ";
  os << "interactionClassList: " << value.getInteractionClassList();
  os << ", ";
  os << "objectClassList: " << value.getObjectClassList();
  os << ", ";
  os << "updateRateList: " << value.getUpdateRateList();
  os << ", ";
  os << "switchList: " << value.getSwitchList();
  os << ", ";
  os << "artificialInteractionRoot: " << value.getArtificialInteractionRoot();
  os << ", ";
  os << "artificialObjectRoot: " << value.getArtificialObjectRoot();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMStringModuleList& value)
{
  os << "{ ";
  FOMStringModuleList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMTransportationType& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMTransportationTypeList& value)
{
  os << "{ ";
  FOMTransportationTypeList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMDimension& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "dimensionHandle: " << value.getDimensionHandle();
  os << ", ";
  os << "upperBound: " << value.getUpperBound();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMDimensionList& value)
{
  os << "{ ";
  FOMDimensionList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMRoutingSpace& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "spaceHandle: " << value.getSpaceHandle();
  os << ", ";
  os << "dimensionHandleSet: " << value.getDimensionHandleSet();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMRoutingSpaceList& value)
{
  os << "{ ";
  FOMRoutingSpaceList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMParameter& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "parameterHandle: " << value.getParameterHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMParameterList& value)
{
  os << "{ ";
  FOMParameterList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMInteractionClass& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "interactionClassHandle: " << value.getInteractionClassHandle();
  os << ", ";
  os << "parentInteractionClassHandle: " << value.getParentInteractionClassHandle();
  os << ", ";
  os << "orderType: " << value.getOrderType();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "dimensionHandleSet: " << value.getDimensionHandleSet();
  os << ", ";
  os << "parameterList: " << value.getParameterList();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMInteractionClassList& value)
{
  os << "{ ";
  FOMInteractionClassList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMAttribute& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "attributeHandle: " << value.getAttributeHandle();
  os << ", ";
  os << "orderType: " << value.getOrderType();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "dimensionHandleSet: " << value.getDimensionHandleSet();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMAttributeList& value)
{
  os << "{ ";
  FOMAttributeList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMObjectClass& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "objectClassHandle: " << value.getObjectClassHandle();
  os << ", ";
  os << "parentObjectClassHandle: " << value.getParentObjectClassHandle();
  os << ", ";
  os << "attributeList: " << value.getAttributeList();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMObjectClassList& value)
{
  os << "{ ";
  FOMObjectClassList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMUpdateRate& value)
{
  os << "{ ";
  os << "name: " << value.getName();
  os << ", ";
  os << "updateRateHandle: " << value.getUpdateRateHandle();
  os << ", ";
  os << "rate: " << value.getRate();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMUpdateRateList& value)
{
  os << "{ ";
  FOMUpdateRateList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMSwitch& value)
{
  os << "{ ";
  os << "switchesType: " << value.getSwitchesType();
  os << ", ";
  os << "enabled: " << value.getEnabled();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMSwitchList& value)
{
  os << "{ ";
  FOMSwitchList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMModule& value)
{
  os << "{ ";
  os << "moduleHandle: " << value.getModuleHandle();
  os << ", ";
  os << "transportationTypeList: " << value.getTransportationTypeList();
  os << ", ";
  os << "dimensionList: " << value.getDimensionList();
  os << ", ";
  os << "routingSpaceList: " << value.getRoutingSpaceList();
  os << ", ";
  os << "interactionClassList: " << value.getInteractionClassList();
  os << ", ";
  os << "objectClassList: " << value.getObjectClassList();
  os << ", ";
  os << "updateRateList: " << value.getUpdateRateList();
  os << ", ";
  os << "switchList: " << value.getSwitchList();
  os << ", ";
  os << "artificialInteractionRoot: " << value.getArtificialInteractionRoot();
  os << ", ";
  os << "artificialObjectRoot: " << value.getArtificialObjectRoot();
  os << ", ";
  os << "content: " << value.getContent();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FOMModuleList& value)
{
  os << "{ ";
  FOMModuleList::const_iterator i = value.begin();
  if (i != value.end()) {
    os << *i;
    while (++i != value.end()) {
      os << ", " << *i;
    }
  }
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ConnectionLostMessage& value)
{
  os << "{ ";
  os << "faultDescription: " << value.getFaultDescription();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const CreateFederationExecutionRequestMessage& value)
{
  os << "{ ";
  os << "federationExecution: " << value.getFederationExecution();
  os << ", ";
  os << "logicalTimeFactoryName: " << value.getLogicalTimeFactoryName();
  os << ", ";
  os << "fOMStringModuleList: " << value.getFOMStringModuleList();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const CreateFederationExecutionResponseMessage& value)
{
  os << "{ ";
  os << "createFederationExecutionResponseType: " << value.getCreateFederationExecutionResponseType();
  os << ", ";
  os << "exceptionString: " << value.getExceptionString();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DestroyFederationExecutionRequestMessage& value)
{
  os << "{ ";
  os << "federationExecution: " << value.getFederationExecution();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DestroyFederationExecutionResponseMessage& value)
{
  os << "{ ";
  os << "destroyFederationExecutionResponseType: " << value.getDestroyFederationExecutionResponseType();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const EnumerateFederationExecutionsRequestMessage& value)
{
  os << "{ ";
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const EnumerateFederationExecutionsResponseMessage& value)
{
  os << "{ ";
  os << "federationExecutionInformationVector: " << value.getFederationExecutionInformationVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const InsertFederationExecutionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federationName: " << value.getFederationName();
  os << ", ";
  os << "logicalTimeFactoryName: " << value.getLogicalTimeFactoryName();
  os << ", ";
  os << "configurationParameterMap: " << value.getConfigurationParameterMap();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ShutdownFederationExecutionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const EraseFederationExecutionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ReleaseFederationHandleMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const InsertModulesMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "fOMModuleList: " << value.getFOMModuleList();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const JoinFederationExecutionRequestMessage& value)
{
  os << "{ ";
  os << "federationExecution: " << value.getFederationExecution();
  os << ", ";
  os << "federateType: " << value.getFederateType();
  os << ", ";
  os << "federateName: " << value.getFederateName();
  os << ", ";
  os << "fOMStringModuleList: " << value.getFOMStringModuleList();
  os << ", ";
  os << "configurationParameterMap: " << value.getConfigurationParameterMap();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const JoinFederationExecutionResponseMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "joinFederationExecutionResponseType: " << value.getJoinFederationExecutionResponseType();
  os << ", ";
  os << "exceptionString: " << value.getExceptionString();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "federateType: " << value.getFederateType();
  os << ", ";
  os << "federateName: " << value.getFederateName();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ResignFederationExecutionLeafRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "resignAction: " << value.getResignAction();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ResignFederationExecutionRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const JoinFederateNotifyMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "federateType: " << value.getFederateType();
  os << ", ";
  os << "federateName: " << value.getFederateName();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ResignFederateNotifyMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ChangeAutomaticResignDirectiveMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "resignAction: " << value.getResignAction();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegisterFederationSynchronizationPointMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "label: " << value.getLabel();
  os << ", ";
  os << "tag: " << value.getTag();
  os << ", ";
  os << "federateHandleVector: " << value.getFederateHandleVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegisterFederationSynchronizationPointResponseMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "label: " << value.getLabel();
  os << ", ";
  os << "registerFederationSynchronizationPointResponseType: " << value.getRegisterFederationSynchronizationPointResponseType();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AnnounceSynchronizationPointMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "label: " << value.getLabel();
  os << ", ";
  os << "tag: " << value.getTag();
  os << ", ";
  os << "addJoiningFederates: " << value.getAddJoiningFederates();
  os << ", ";
  os << "federateHandleVector: " << value.getFederateHandleVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const SynchronizationPointAchievedMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "label: " << value.getLabel();
  os << ", ";
  os << "federateHandleBoolPairVector: " << value.getFederateHandleBoolPairVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const FederationSynchronizedMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "label: " << value.getLabel();
  os << ", ";
  os << "federateHandleBoolPairVector: " << value.getFederateHandleBoolPairVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const EnableTimeRegulationRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "timeStamp: " << value.getTimeStamp();
  os << ", ";
  os << "commitId: " << value.getCommitId();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const EnableTimeRegulationResponseMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "respondingFederateHandle: " << value.getRespondingFederateHandle();
  os << ", ";
  os << "timeStampValid: " << value.getTimeStampValid();
  os << ", ";
  os << "timeStamp: " << value.getTimeStamp();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DisableTimeRegulationRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const CommitLowerBoundTimeStampMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "timeStamp: " << value.getTimeStamp();
  os << ", ";
  os << "commitType: " << value.getCommitType();
  os << ", ";
  os << "commitId: " << value.getCommitId();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const CommitLowerBoundTimeStampResponseMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "sendingFederateHandle: " << value.getSendingFederateHandle();
  os << ", ";
  os << "commitId: " << value.getCommitId();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const LockedByNextMessageRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "sendingFederateHandle: " << value.getSendingFederateHandle();
  os << ", ";
  os << "lockedByNextMessage: " << value.getLockedByNextMessage();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TimeConstrainedEnabledMessage& value)
{
  os << "{ ";
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TimeRegulationEnabledMessage& value)
{
  os << "{ ";
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TimeAdvanceGrantedMessage& value)
{
  os << "{ ";
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const InsertRegionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "regionHandleDimensionHandleSetPairVector: " << value.getRegionHandleDimensionHandleSetPairVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const CommitRegionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "regionHandleRegionValuePairVector: " << value.getRegionHandleRegionValuePairVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const EraseRegionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "regionHandleVector: " << value.getRegionHandleVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ChangeInteractionClassPublicationMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "publicationType: " << value.getPublicationType();
  os << ", ";
  os << "interactionClassHandle: " << value.getInteractionClassHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ChangeObjectClassPublicationMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "publicationType: " << value.getPublicationType();
  os << ", ";
  os << "objectClassHandle: " << value.getObjectClassHandle();
  os << ", ";
  os << "attributeHandles: " << value.getAttributeHandles();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ChangeInteractionClassSubscriptionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "subscriptionType: " << value.getSubscriptionType();
  os << ", ";
  os << "interactionClassHandle: " << value.getInteractionClassHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ChangeObjectClassSubscriptionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "subscriptionType: " << value.getSubscriptionType();
  os << ", ";
  os << "objectClassHandle: " << value.getObjectClassHandle();
  os << ", ";
  os << "attributeHandles: " << value.getAttributeHandles();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RegistrationForObjectClassMessage& value)
{
  os << "{ ";
  os << "objectClassHandle: " << value.getObjectClassHandle();
  os << ", ";
  os << "start: " << value.getStart();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributesInScopeMessage& value)
{
  os << "{ ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "attributeHandles: " << value.getAttributeHandles();
  os << ", ";
  os << "inScope: " << value.getInScope();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TurnUpdatesOnForInstanceMessage& value)
{
  os << "{ ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "attributeHandles: " << value.getAttributeHandles();
  os << ", ";
  os << "updateRate: " << value.getUpdateRate();
  os << ", ";
  os << "on: " << value.getOn();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TurnInteractionsOnMessage& value)
{
  os << "{ ";
  os << "interactionClassHandle: " << value.getInteractionClassHandle();
  os << ", ";
  os << "on: " << value.getOn();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const InteractionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "interactionClassHandle: " << value.getInteractionClassHandle();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "tag: " << value.getTag();
  os << ", ";
  os << "parameterValues: " << value.getParameterValues();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TimeStampedInteractionMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "interactionClassHandle: " << value.getInteractionClassHandle();
  os << ", ";
  os << "orderType: " << value.getOrderType();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "tag: " << value.getTag();
  os << ", ";
  os << "timeStamp: " << value.getTimeStamp();
  os << ", ";
  os << "messageRetractionHandle: " << value.getMessageRetractionHandle();
  os << ", ";
  os << "parameterValues: " << value.getParameterValues();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ObjectInstanceHandlesRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "count: " << value.getCount();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ObjectInstanceHandlesResponseMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "objectInstanceHandleNamePairVector: " << value.getObjectInstanceHandleNamePairVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ReleaseMultipleObjectInstanceNameHandlePairsMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "objectInstanceHandleVector: " << value.getObjectInstanceHandleVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ReserveObjectInstanceNameRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "name: " << value.getName();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ReserveObjectInstanceNameResponseMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "objectInstanceHandleNamePair: " << value.getObjectInstanceHandleNamePair();
  os << ", ";
  os << "success: " << value.getSuccess();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ReserveMultipleObjectInstanceNameRequestMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "nameList: " << value.getNameList();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const ReserveMultipleObjectInstanceNameResponseMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "objectInstanceHandleNamePairVector: " << value.getObjectInstanceHandleNamePairVector();
  os << ", ";
  os << "success: " << value.getSuccess();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const InsertObjectInstanceMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "objectClassHandle: " << value.getObjectClassHandle();
  os << ", ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "name: " << value.getName();
  os << ", ";
  os << "attributeStateVector: " << value.getAttributeStateVector();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const DeleteObjectInstanceMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "tag: " << value.getTag();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TimeStampedDeleteObjectInstanceMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "orderType: " << value.getOrderType();
  os << ", ";
  os << "tag: " << value.getTag();
  os << ", ";
  os << "timeStamp: " << value.getTimeStamp();
  os << ", ";
  os << "messageRetractionHandle: " << value.getMessageRetractionHandle();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const AttributeUpdateMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "tag: " << value.getTag();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "attributeValues: " << value.getAttributeValues();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const TimeStampedAttributeUpdateMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "federateHandle: " << value.getFederateHandle();
  os << ", ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "tag: " << value.getTag();
  os << ", ";
  os << "timeStamp: " << value.getTimeStamp();
  os << ", ";
  os << "messageRetractionHandle: " << value.getMessageRetractionHandle();
  os << ", ";
  os << "orderType: " << value.getOrderType();
  os << ", ";
  os << "transportationType: " << value.getTransportationType();
  os << ", ";
  os << "attributeValues: " << value.getAttributeValues();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RequestAttributeUpdateMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "objectInstanceHandle: " << value.getObjectInstanceHandle();
  os << ", ";
  os << "attributeHandles: " << value.getAttributeHandles();
  os << ", ";
  os << "tag: " << value.getTag();
  os << " }";
  return os;
}

template<typename char_type, typename traits_type>
std::basic_ostream<char_type, traits_type>&
operator<<(std::basic_ostream<char_type, traits_type>& os, const RequestClassAttributeUpdateMessage& value)
{
  os << "{ ";
  os << "federationHandle: " << value.getFederationHandle();
  os << ", ";
  os << "objectClassHandle: " << value.getObjectClassHandle();
  os << ", ";
  os << "attributeHandles: " << value.getAttributeHandles();
  os << ", ";
  os << "tag: " << value.getTag();
  os << " }";
  return os;
}

} // namespace OpenRTI

#endif
